src/cmd/internal/obj/ppc64/asm9.go

   1 // cmd/9l/optab.c, cmd/9l/asmout.c from Vita Nuova.
   2 //
   3 //      Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
   4 //      Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
   5 //      Portions Copyright © 1997-1999 Vita Nuova Limited
   6 //      Portions Copyright © 2000-2008 Vita Nuova Holdings Limited (www.vitanuova.com)
   7 //      Portions Copyright © 2004,2006 Bruce Ellis
   8 //      Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
   9 //      Revisions Copyright © 2000-2008 Lucent Technologies Inc. and others
  10 //      Portions Copyright © 2009 The Go Authors. All rights reserved.
  11 //
  12 // Permission is hereby granted, free of charge, to any person obtaining a copy
  13 // of this software and associated documentation files (the "Software"), to deal
  14 // in the Software without restriction, including without limitation the rights
  15 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  16 // copies of the Software, and to permit persons to whom the Software is
  17 // furnished to do so, subject to the following conditions:
  18 //
  19 // The above copyright notice and this permission notice shall be included in
  20 // all copies or substantial portions of the Software.
  21 //
  22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  23 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  24 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  25 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  26 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  27 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  28 // THE SOFTWARE.
  29
  30 package ppc64
  31
  32 import (
  33         "cmd/internal/obj"
  34         "cmd/internal/objabi"
  35         "encoding/binary"
  36         "fmt"
  37         "log"
  38         "math"
  39         "sort"
  40 )
  41
  42 // ctxt9 holds state while assembling a single function.
  43 // Each function gets a fresh ctxt9.
  44 // This allows for multiple functions to be safely concurrently assembled.
  45 type ctxt9 struct {
  46         ctxt       *obj.Link
  47         newprog    obj.ProgAlloc
  48         cursym     *obj.LSym
  49         autosize   int32
  50         instoffset int64
  51         pc         int64
  52 }
  53
  54 // Instruction layout.
  55
  56 const (
  57         funcAlign     = 16
  58         funcAlignMask = funcAlign - 1
  59 )
  60
  61 const (
  62         r0iszero = 1
  63 )
  64
  65 type Optab struct {
  66         as    obj.As // Opcode
  67         a1    uint8  // p.From argument (obj.Addr). p is of type obj.Prog.
  68         a2    uint8  // p.Reg argument (int16 Register)
  69         a3    uint8  // p.RestArgs[0]  (obj.AddrPos)
  70         a4    uint8  // p.RestArgs[1]
  71         a5    uint8  // p.RestARgs[2]
  72         a6    uint8  // p.To (obj.Addr)
  73         type_ int8   // cases in asmout below. E.g., 44 = st r,(ra+rb); 45 = ld (ra+rb), r
  74         size  int8   // Text space in bytes to lay operation
  75 }
  76
  77 // optab contains an array to be sliced of accepted operand combinations for an
  78 // instruction. Unused arguments and fields are not explicitly enumerated, and
  79 // should not be listed for clarity. Unused arguments and values should always
  80 // assume the default value for the given type.
  81 //
  82 // optab does not list every valid ppc64 opcode, it enumerates representative
  83 // operand combinations for a class of instruction.  The variable oprange indexes
  84 // all valid ppc64 opcodes.
  85 //
  86 // oprange is initialized to point a slice within optab which contains the valid
  87 // operand combinations for a given instruction.  This is initialized from buildop.
  88 //
  89 // Likewise, each slice of optab is dynamically sorted using the ocmp Sort interface
  90 // to arrange entries to minimize text size of each opcode.
  91 var optab = []Optab{
  92         {as: obj.ATEXT, a1: C_LOREG, a6: C_TEXTSIZE, type_: 0, size: 0},
  93         {as: obj.ATEXT, a1: C_LOREG, a3: C_LCON, a6: C_TEXTSIZE, type_: 0, size: 0},
  94         {as: obj.ATEXT, a1: C_ADDR, a6: C_TEXTSIZE, type_: 0, size: 0},
  95         {as: obj.ATEXT, a1: C_ADDR, a3: C_LCON, a6: C_TEXTSIZE, type_: 0, size: 0},
  96         /* move register */
  97         {as: AADD, a1: C_REG, a2: C_REG, a6: C_REG, type_: 2, size: 4},
  98         {as: AADD, a1: C_REG, a6: C_REG, type_: 2, size: 4},
  99         {as: AADD, a1: C_SCON, a2: C_REG, a6: C_REG, type_: 4, size: 4},
 100         {as: AADD, a1: C_SCON, a6: C_REG, type_: 4, size: 4},
 101         {as: AADD, a1: C_ADDCON, a2: C_REG, a6: C_REG, type_: 4, size: 4},
 102         {as: AADD, a1: C_ADDCON, a6: C_REG, type_: 4, size: 4},
 103         {as: AADD, a1: C_UCON, a2: C_REG, a6: C_REG, type_: 20, size: 4},
 104         {as: AADD, a1: C_UCON, a6: C_REG, type_: 20, size: 4},
 105         {as: AADD, a1: C_ANDCON, a2: C_REG, a6: C_REG, type_: 22, size: 8},
 106         {as: AADD, a1: C_ANDCON, a6: C_REG, type_: 22, size: 8},
 107         {as: AADD, a1: C_LCON, a2: C_REG, a6: C_REG, type_: 22, size: 12},
 108         {as: AADD, a1: C_LCON, a6: C_REG, type_: 22, size: 12},
 109         {as: AADDIS, a1: C_ADDCON, a2: C_REG, a6: C_REG, type_: 20, size: 4},
 110         {as: AADDIS, a1: C_ADDCON, a6: C_REG, type_: 20, size: 4},
 111         {as: AADDC, a1: C_REG, a2: C_REG, a6: C_REG, type_: 2, size: 4},
 112         {as: AADDC, a1: C_REG, a6: C_REG, type_: 2, size: 4},
 113         {as: AADDC, a1: C_ADDCON, a2: C_REG, a6: C_REG, type_: 4, size: 4},
 114         {as: AADDC, a1: C_ADDCON, a6: C_REG, type_: 4, size: 4},
 115         {as: AADDC, a1: C_LCON, a2: C_REG, a6: C_REG, type_: 22, size: 12},
 116         {as: AADDC, a1: C_LCON, a6: C_REG, type_: 22, size: 12},
 117         {as: AAND, a1: C_REG, a2: C_REG, a6: C_REG, type_: 6, size: 4}, /* logical, no literal */
 118         {as: AAND, a1: C_REG, a6: C_REG, type_: 6, size: 4},
 119         {as: AANDCC, a1: C_REG, a2: C_REG, a6: C_REG, type_: 6, size: 4},
 120         {as: AANDCC, a1: C_REG, a6: C_REG, type_: 6, size: 4},
 121         {as: AANDCC, a1: C_ANDCON, a6: C_REG, type_: 58, size: 4},
 122         {as: AANDCC, a1: C_ANDCON, a2: C_REG, a6: C_REG, type_: 58, size: 4},
 123         {as: AANDCC, a1: C_UCON, a6: C_REG, type_: 59, size: 4},
 124         {as: AANDCC, a1: C_UCON, a2: C_REG, a6: C_REG, type_: 59, size: 4},
 125         {as: AANDCC, a1: C_ADDCON, a6: C_REG, type_: 23, size: 8},
 126         {as: AANDCC, a1: C_ADDCON, a2: C_REG, a6: C_REG, type_: 23, size: 8},
 127         {as: AANDCC, a1: C_LCON, a6: C_REG, type_: 23, size: 12},
 128         {as: AANDCC, a1: C_LCON, a2: C_REG, a6: C_REG, type_: 23, size: 12},
 129         {as: AANDISCC, a1: C_ANDCON, a6: C_REG, type_: 59, size: 4},
 130         {as: AANDISCC, a1: C_ANDCON, a2: C_REG, a6: C_REG, type_: 59, size: 4},
 131         {as: AMULLW, a1: C_REG, a2: C_REG, a6: C_REG, type_: 2, size: 4},
 132         {as: AMULLW, a1: C_REG, a6: C_REG, type_: 2, size: 4},
 133         {as: AMULLW, a1: C_ADDCON, a2: C_REG, a6: C_REG, type_: 4, size: 4},
 134         {as: AMULLW, a1: C_ADDCON, a6: C_REG, type_: 4, size: 4},
 135         {as: AMULLW, a1: C_ANDCON, a2: C_REG, a6: C_REG, type_: 4, size: 4},
 136         {as: AMULLW, a1: C_ANDCON, a6: C_REG, type_: 4, size: 4},
 137         {as: AMULLW, a1: C_LCON, a2: C_REG, a6: C_REG, type_: 22, size: 12},
 138         {as: AMULLW, a1: C_LCON, a6: C_REG, type_: 22, size: 12},
 139         {as: ASUBC, a1: C_REG, a2: C_REG, a6: C_REG, type_: 10, size: 4},
 140         {as: ASUBC, a1: C_REG, a6: C_REG, type_: 10, size: 4},
 141         {as: ASUBC, a1: C_REG, a3: C_ADDCON, a6: C_REG, type_: 27, size: 4},
 142         {as: ASUBC, a1: C_REG, a3: C_LCON, a6: C_REG, type_: 28, size: 12},
 143         {as: AOR, a1: C_REG, a2: C_REG, a6: C_REG, type_: 6, size: 4}, /* logical, literal not cc (or/xor) */
 144         {as: AOR, a1: C_REG, a6: C_REG, type_: 6, size: 4},
 145         {as: AOR, a1: C_ANDCON, a6: C_REG, type_: 58, size: 4},
 146         {as: AOR, a1: C_ANDCON, a2: C_REG, a6: C_REG, type_: 58, size: 4},
 147         {as: AOR, a1: C_UCON, a6: C_REG, type_: 59, size: 4},
 148         {as: AOR, a1: C_UCON, a2: C_REG, a6: C_REG, type_: 59, size: 4},
 149         {as: AOR, a1: C_ADDCON, a6: C_REG, type_: 23, size: 8},
 150         {as: AOR, a1: C_ADDCON, a2: C_REG, a6: C_REG, type_: 23, size: 8},
 151         {as: AOR, a1: C_LCON, a6: C_REG, type_: 23, size: 12},
 152         {as: AOR, a1: C_LCON, a2: C_REG, a6: C_REG, type_: 23, size: 12},
 153         {as: AORIS, a1: C_ANDCON, a6: C_REG, type_: 59, size: 4},
 154         {as: AORIS, a1: C_ANDCON, a2: C_REG, a6: C_REG, type_: 59, size: 4},
 155         {as: ADIVW, a1: C_REG, a2: C_REG, a6: C_REG, type_: 2, size: 4}, /* op r1[,r2],r3 */
 156         {as: ADIVW, a1: C_REG, a6: C_REG, type_: 2, size: 4},
 157         {as: ASUB, a1: C_REG, a2: C_REG, a6: C_REG, type_: 10, size: 4}, /* op r2[,r1],r3 */
 158         {as: ASUB, a1: C_REG, a6: C_REG, type_: 10, size: 4},
 159         {as: ASLW, a1: C_REG, a6: C_REG, type_: 6, size: 4},
 160         {as: ASLW, a1: C_REG, a2: C_REG, a6: C_REG, type_: 6, size: 4},
 161         {as: ASLD, a1: C_REG, a6: C_REG, type_: 6, size: 4},
 162         {as: ASLD, a1: C_REG, a2: C_REG, a6: C_REG, type_: 6, size: 4},
 163         {as: ASLD, a1: C_SCON, a2: C_REG, a6: C_REG, type_: 25, size: 4},
 164         {as: ASLD, a1: C_SCON, a6: C_REG, type_: 25, size: 4},
 165         {as: AEXTSWSLI, a1: C_SCON, a6: C_REG, type_: 25, size: 4},
 166         {as: AEXTSWSLI, a1: C_SCON, a2: C_REG, a6: C_REG, type_: 25, size: 4},
 167         {as: ASLW, a1: C_SCON, a2: C_REG, a6: C_REG, type_: 57, size: 4},
 168         {as: ASLW, a1: C_SCON, a6: C_REG, type_: 57, size: 4},
 169         {as: ASRAW, a1: C_REG, a6: C_REG, type_: 6, size: 4},
 170         {as: ASRAW, a1: C_REG, a2: C_REG, a6: C_REG, type_: 6, size: 4},
 171         {as: ASRAW, a1: C_SCON, a2: C_REG, a6: C_REG, type_: 56, size: 4},
 172         {as: ASRAW, a1: C_SCON, a6: C_REG, type_: 56, size: 4},
 173         {as: ASRAD, a1: C_REG, a6: C_REG, type_: 6, size: 4},
 174         {as: ASRAD, a1: C_REG, a2: C_REG, a6: C_REG, type_: 6, size: 4},
 175         {as: ASRAD, a1: C_SCON, a2: C_REG, a6: C_REG, type_: 56, size: 4},
 176         {as: ASRAD, a1: C_SCON, a6: C_REG, type_: 56, size: 4},
 177         {as: ARLWMI, a1: C_SCON, a2: C_REG, a3: C_LCON, a6: C_REG, type_: 62, size: 4},
 178         {as: ARLWMI, a1: C_SCON, a2: C_REG, a3: C_SCON, a4: C_SCON, a6: C_REG, type_: 102, size: 4},
 179         {as: ARLWMI, a1: C_REG, a2: C_REG, a3: C_LCON, a6: C_REG, type_: 63, size: 4},
 180         {as: ARLWMI, a1: C_REG, a2: C_REG, a3: C_SCON, a4: C_SCON, a6: C_REG, type_: 103, size: 4},
 181         {as: ACLRLSLWI, a1: C_SCON, a2: C_REG, a3: C_LCON, a6: C_REG, type_: 62, size: 4},
 182         {as: ARLDMI, a1: C_SCON, a2: C_REG, a3: C_LCON, a6: C_REG, type_: 30, size: 4},
 183         {as: ARLDC, a1: C_SCON, a2: C_REG, a3: C_LCON, a6: C_REG, type_: 29, size: 4},
 184         {as: ARLDCL, a1: C_SCON, a2: C_REG, a3: C_LCON, a6: C_REG, type_: 29, size: 4},
 185         {as: ARLDCL, a1: C_REG, a2: C_REG, a3: C_LCON, a6: C_REG, type_: 14, size: 4},
 186         {as: ARLDICL, a1: C_REG, a2: C_REG, a3: C_LCON, a6: C_REG, type_: 14, size: 4},
 187         {as: ARLDICL, a1: C_SCON, a2: C_REG, a3: C_LCON, a6: C_REG, type_: 14, size: 4},
 188         {as: ARLDCL, a1: C_REG, a3: C_LCON, a6: C_REG, type_: 14, size: 4},
 189         {as: AFADD, a1: C_FREG, a6: C_FREG, type_: 2, size: 4},
 190         {as: AFADD, a1: C_FREG, a2: C_FREG, a6: C_FREG, type_: 2, size: 4},
 191         {as: AFABS, a1: C_FREG, a6: C_FREG, type_: 33, size: 4},
 192         {as: AFABS, a6: C_FREG, type_: 33, size: 4},
 193         {as: AFMADD, a1: C_FREG, a2: C_FREG, a3: C_FREG, a6: C_FREG, type_: 34, size: 4},
 194         {as: AFMUL, a1: C_FREG, a6: C_FREG, type_: 32, size: 4},
 195         {as: AFMUL, a1: C_FREG, a2: C_FREG, a6: C_FREG, type_: 32, size: 4},
 196
 197         {as: AMOVBU, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 198         {as: AMOVBU, a1: C_SOREG, a6: C_REG, type_: 9, size: 8},
 199
 200         {as: AMOVBZU, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 201         {as: AMOVBZU, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
 202
 203         {as: AMOVHBR, a1: C_REG, a6: C_ZOREG, type_: 44, size: 4},
 204         {as: AMOVHBR, a1: C_ZOREG, a6: C_REG, type_: 45, size: 4},
 205
 206         {as: AMOVB, a1: C_ADDR, a6: C_REG, type_: 76, size: 12},
 207         {as: AMOVB, a1: C_LOREG, a6: C_REG, type_: 37, size: 12},
 208         {as: AMOVB, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
 209         {as: AMOVB, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
 210         {as: AMOVB, a1: C_REG, a6: C_REG, type_: 12, size: 4},
 211         {as: AMOVB, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 212         {as: AMOVB, a1: C_SOREG, a6: C_REG, type_: 9, size: 8},
 213
 214         {as: AMOVBZ, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
 215         {as: AMOVBZ, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
 216         {as: AMOVBZ, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
 217         {as: AMOVBZ, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
 218         {as: AMOVBZ, a1: C_REG, a6: C_REG, type_: 13, size: 4},
 219         {as: AMOVBZ, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 220         {as: AMOVBZ, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
 221
 222         {as: AMOVD, a1: C_ADDCON, a6: C_REG, type_: 3, size: 4},
 223         {as: AMOVD, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
 224         {as: AMOVD, a1: C_ANDCON, a6: C_REG, type_: 3, size: 4},
 225         {as: AMOVD, a1: C_CTR, a6: C_REG, type_: 66, size: 4},
 226         {as: AMOVD, a1: C_GOTADDR, a6: C_REG, type_: 81, size: 8},
 227         {as: AMOVD, a1: C_LACON, a6: C_REG, type_: 26, size: 8},
 228         {as: AMOVD, a1: C_LCON, a6: C_REG, type_: 19, size: 8},
 229         {as: AMOVD, a1: C_LECON, a6: C_REG, type_: 26, size: 8},
 230         {as: AMOVD, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
 231         {as: AMOVD, a1: C_LR, a6: C_REG, type_: 66, size: 4},
 232         {as: AMOVD, a1: C_MSR, a6: C_REG, type_: 54, size: 4}, /* mfmsr */
 233         {as: AMOVD, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
 234         {as: AMOVD, a1: C_REG, a6: C_CTR, type_: 66, size: 4},
 235         {as: AMOVD, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
 236         {as: AMOVD, a1: C_REG, a6: C_LR, type_: 66, size: 4},
 237         {as: AMOVD, a1: C_REG, a6: C_MSR, type_: 54, size: 4}, /* mtmsrd */
 238         {as: AMOVD, a1: C_REG, a6: C_REG, type_: 1, size: 4},
 239         {as: AMOVD, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 240         {as: AMOVD, a1: C_REG, a6: C_SPR, type_: 66, size: 4},
 241         {as: AMOVD, a1: C_REG, a6: C_XER, type_: 66, size: 4},
 242         {as: AMOVD, a1: C_SACON, a6: C_REG, type_: 3, size: 4},
 243         {as: AMOVD, a1: C_SECON, a6: C_REG, type_: 3, size: 4},
 244         {as: AMOVD, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
 245         {as: AMOVD, a1: C_SPR, a6: C_REG, type_: 66, size: 4},
 246         {as: AMOVD, a1: C_TLS_IE, a6: C_REG, type_: 80, size: 8},
 247         {as: AMOVD, a1: C_TLS_LE, a6: C_REG, type_: 79, size: 4},
 248         {as: AMOVD, a1: C_TOCADDR, a6: C_REG, type_: 95, size: 8},
 249         {as: AMOVD, a1: C_UCON, a6: C_REG, type_: 3, size: 4},
 250         {as: AMOVD, a1: C_XER, a6: C_REG, type_: 66, size: 4},
 251
 252         {as: AMOVW, a1: C_ADDCON, a6: C_REG, type_: 3, size: 4},
 253         {as: AMOVW, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
 254         {as: AMOVW, a1: C_ANDCON, a6: C_REG, type_: 3, size: 4},
 255         {as: AMOVW, a1: C_CREG, a6: C_REG, type_: 68, size: 4},
 256         {as: AMOVW, a1: C_LACON, a6: C_REG, type_: 26, size: 8},
 257         {as: AMOVW, a1: C_LCON, a6: C_REG, type_: 19, size: 8},
 258         {as: AMOVW, a1: C_LECON, a6: C_REG, type_: 26, size: 8},
 259         {as: AMOVW, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
 260         {as: AMOVW, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
 261         {as: AMOVW, a1: C_REG, a6: C_CREG, type_: 69, size: 4},
 262         {as: AMOVW, a1: C_REG, a6: C_CTR, type_: 66, size: 4},
 263         {as: AMOVW, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
 264         {as: AMOVW, a1: C_REG, a6: C_REG, type_: 12, size: 4},
 265         {as: AMOVW, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 266         {as: AMOVW, a1: C_REG, a6: C_SPR, type_: 66, size: 4},
 267         {as: AMOVW, a1: C_REG, a6: C_XER, type_: 66, size: 4},
 268         {as: AMOVW, a1: C_SACON, a6: C_REG, type_: 3, size: 4},
 269         {as: AMOVW, a1: C_SECON, a6: C_REG, type_: 3, size: 4}, /* TO DO: check */
 270         {as: AMOVW, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
 271         {as: AMOVW, a1: C_SPR, a6: C_REG, type_: 66, size: 4},
 272         {as: AMOVW, a1: C_UCON, a6: C_REG, type_: 3, size: 4},
 273         {as: AMOVW, a1: C_XER, a6: C_REG, type_: 66, size: 4},
 274
 275         {as: AMOVWZ, a1: C_ADDCON, a6: C_REG, type_: 3, size: 4},
 276         {as: AMOVWZ, a1: C_ADDR, a6: C_REG, type_: 75, size: 8},
 277         {as: AMOVWZ, a1: C_ANDCON, a6: C_REG, type_: 3, size: 4},
 278         {as: AMOVWZ, a1: C_CREG, a6: C_REG, type_: 68, size: 4},
 279         {as: AMOVWZ, a1: C_LACON, a6: C_REG, type_: 26, size: 8},
 280         {as: AMOVWZ, a1: C_LCON, a6: C_REG, type_: 19, size: 8},
 281         {as: AMOVWZ, a1: C_LECON, a6: C_REG, type_: 26, size: 8},
 282         {as: AMOVWZ, a1: C_LOREG, a6: C_REG, type_: 36, size: 8},
 283         {as: AMOVWZ, a1: C_REG, a6: C_ADDR, type_: 74, size: 8},
 284         {as: AMOVWZ, a1: C_REG, a6: C_CREG, type_: 69, size: 4},
 285         {as: AMOVWZ, a1: C_REG, a6: C_CTR, type_: 66, size: 4},
 286         {as: AMOVWZ, a1: C_REG, a6: C_LOREG, type_: 35, size: 8},
 287         {as: AMOVWZ, a1: C_REG, a6: C_MSR, type_: 54, size: 4}, /* mtmsr */
 288         {as: AMOVWZ, a1: C_REG, a6: C_REG, type_: 13, size: 4},
 289         {as: AMOVWZ, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 290         {as: AMOVWZ, a1: C_REG, a6: C_SPR, type_: 66, size: 4},
 291         {as: AMOVWZ, a1: C_REG, a6: C_XER, type_: 66, size: 4},
 292         {as: AMOVWZ, a1: C_SACON, a6: C_REG, type_: 3, size: 4},
 293         {as: AMOVWZ, a1: C_SECON, a6: C_REG, type_: 3, size: 4}, /* TO DO: check */
 294         {as: AMOVWZ, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
 295         {as: AMOVWZ, a1: C_SPR, a6: C_REG, type_: 66, size: 4},
 296         {as: AMOVWZ, a1: C_UCON, a6: C_REG, type_: 3, size: 4},
 297         {as: AMOVWZ, a1: C_XER, a6: C_REG, type_: 66, size: 4},
 298
 299         {as: AMOVFL, a1: C_CREG, a6: C_CREG, type_: 67, size: 4},
 300         {as: AMOVFL, a1: C_FPSCR, a6: C_CREG, type_: 73, size: 4},
 301         {as: AMOVFL, a1: C_FPSCR, a6: C_FREG, type_: 53, size: 4},
 302         {as: AMOVFL, a1: C_FREG, a3: C_LCON, a6: C_FPSCR, type_: 64, size: 4},
 303         {as: AMOVFL, a1: C_FREG, a6: C_FPSCR, type_: 64, size: 4},
 304         {as: AMOVFL, a1: C_LCON, a6: C_FPSCR, type_: 65, size: 4},
 305         {as: AMOVFL, a1: C_REG, a6: C_CREG, type_: 69, size: 4},
 306         {as: AMOVFL, a1: C_REG, a6: C_LCON, type_: 69, size: 4},
 307
 308         {as: ASYSCALL, type_: 5, size: 4},
 309         {as: ASYSCALL, a1: C_REG, type_: 77, size: 12},
 310         {as: ASYSCALL, a1: C_SCON, type_: 77, size: 12},
 311         {as: ABEQ, a6: C_SBRA, type_: 16, size: 4},
 312         {as: ABEQ, a1: C_CREG, a6: C_SBRA, type_: 16, size: 4},
 313         {as: ABR, a6: C_LBRA, type_: 11, size: 4},
 314         {as: ABR, a6: C_LBRAPIC, type_: 11, size: 8},
 315         {as: ABC, a1: C_SCON, a2: C_REG, a6: C_SBRA, type_: 16, size: 4},
 316         {as: ABC, a1: C_SCON, a2: C_REG, a6: C_LBRA, type_: 17, size: 4},
 317         {as: ABR, a6: C_LR, type_: 18, size: 4},
 318         {as: ABR, a3: C_SCON, a6: C_LR, type_: 18, size: 4},
 319         {as: ABR, a6: C_CTR, type_: 18, size: 4},
 320         {as: ABR, a1: C_REG, a6: C_CTR, type_: 18, size: 4},
 321         {as: ABR, a6: C_ZOREG, type_: 15, size: 8},
 322         {as: ABC, a2: C_REG, a6: C_LR, type_: 18, size: 4},
 323         {as: ABC, a2: C_REG, a6: C_CTR, type_: 18, size: 4},
 324         {as: ABC, a1: C_SCON, a2: C_REG, a6: C_LR, type_: 18, size: 4},
 325         {as: ABC, a1: C_SCON, a2: C_REG, a6: C_CTR, type_: 18, size: 4},
 326         {as: ABC, a6: C_ZOREG, type_: 15, size: 8},
 327         {as: AFMOVD, a1: C_FREG, a6: C_FREG, type_: 33, size: 4},
 328         {as: AFMOVD, a1: C_SOREG, a6: C_FREG, type_: 8, size: 4},
 329         {as: AFMOVD, a1: C_LOREG, a6: C_FREG, type_: 36, size: 8},
 330         {as: AFMOVD, a1: C_ZCON, a6: C_FREG, type_: 24, size: 4},
 331         {as: AFMOVD, a1: C_ADDCON, a6: C_FREG, type_: 24, size: 8},
 332         {as: AFMOVD, a1: C_ADDR, a6: C_FREG, type_: 75, size: 8},
 333         {as: AFMOVD, a1: C_FREG, a6: C_SOREG, type_: 7, size: 4},
 334         {as: AFMOVD, a1: C_FREG, a6: C_LOREG, type_: 35, size: 8},
 335         {as: AFMOVD, a1: C_FREG, a6: C_ADDR, type_: 74, size: 8},
 336         {as: AFMOVSX, a1: C_ZOREG, a6: C_FREG, type_: 45, size: 4},
 337         {as: AFMOVSX, a1: C_FREG, a6: C_ZOREG, type_: 44, size: 4},
 338         {as: AFMOVSZ, a1: C_ZOREG, a6: C_FREG, type_: 45, size: 4},
 339         {as: ASYNC, type_: 46, size: 4},
 340         {as: AWORD, a1: C_LCON, type_: 40, size: 4},
 341         {as: ADWORD, a1: C_LCON, type_: 31, size: 8},
 342         {as: ADWORD, a1: C_DCON, type_: 31, size: 8},
 343         {as: AADDME, a1: C_REG, a6: C_REG, type_: 47, size: 4},
 344         {as: AEXTSB, a1: C_REG, a6: C_REG, type_: 48, size: 4},
 345         {as: AEXTSB, a6: C_REG, type_: 48, size: 4},
 346         {as: AISEL, a1: C_LCON, a2: C_REG, a3: C_REG, a6: C_REG, type_: 84, size: 4},
 347         {as: AISEL, a1: C_ZCON, a2: C_REG, a3: C_REG, a6: C_REG, type_: 84, size: 4},
 348         {as: ANEG, a1: C_REG, a6: C_REG, type_: 47, size: 4},
 349         {as: ANEG, a6: C_REG, type_: 47, size: 4},
 350         {as: AREM, a1: C_REG, a6: C_REG, type_: 50, size: 12},
 351         {as: AREM, a1: C_REG, a2: C_REG, a6: C_REG, type_: 50, size: 12},
 352         {as: AREMU, a1: C_REG, a6: C_REG, type_: 50, size: 16},
 353         {as: AREMU, a1: C_REG, a2: C_REG, a6: C_REG, type_: 50, size: 16},
 354         {as: AREMD, a1: C_REG, a6: C_REG, type_: 51, size: 12},
 355         {as: AREMD, a1: C_REG, a2: C_REG, a6: C_REG, type_: 51, size: 12},
 356         {as: AMTFSB0, a1: C_SCON, type_: 52, size: 4},
 357         /* Other ISA 2.05+ instructions */
 358         {as: APOPCNTD, a1: C_REG, a6: C_REG, type_: 93, size: 4},            /* population count, x-form */
 359         {as: ACMPB, a1: C_REG, a2: C_REG, a6: C_REG, type_: 92, size: 4},    /* compare byte, x-form */
 360         {as: ACMPEQB, a1: C_REG, a2: C_REG, a6: C_CREG, type_: 92, size: 4}, /* compare equal byte, x-form, ISA 3.0 */
 361         {as: ACMPEQB, a1: C_REG, a6: C_REG, type_: 70, size: 4},
 362         {as: AFTDIV, a1: C_FREG, a2: C_FREG, a6: C_SCON, type_: 92, size: 4},          /* floating test for sw divide, x-form */
 363         {as: AFTSQRT, a1: C_FREG, a6: C_SCON, type_: 93, size: 4},                     /* floating test for sw square root, x-form */
 364         {as: ACOPY, a1: C_REG, a6: C_REG, type_: 92, size: 4},                         /* copy/paste facility, x-form */
 365         {as: ADARN, a1: C_SCON, a6: C_REG, type_: 92, size: 4},                        /* deliver random number, x-form */
 366         {as: ALDMX, a1: C_SOREG, a6: C_REG, type_: 45, size: 4},                       /* load doubleword monitored, x-form */
 367         {as: AMADDHD, a1: C_REG, a2: C_REG, a3: C_REG, a6: C_REG, type_: 83, size: 4}, /* multiply-add high/low doubleword, va-form */
 368         {as: AADDEX, a1: C_REG, a2: C_REG, a3: C_SCON, a6: C_REG, type_: 94, size: 4}, /* add extended using alternate carry, z23-form */
 369         {as: ACRAND, a1: C_CREG, a6: C_CREG, type_: 2, size: 4},                       /* logical ops for condition registers xl-form */
 370
 371         /* Vector instructions */
 372
 373         /* Vector load */
 374         {as: ALV, a1: C_SOREG, a6: C_VREG, type_: 45, size: 4}, /* vector load, x-form */
 375
 376         /* Vector store */
 377         {as: ASTV, a1: C_VREG, a6: C_SOREG, type_: 44, size: 4}, /* vector store, x-form */
 378
 379         /* Vector logical */
 380         {as: AVAND, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4}, /* vector and, vx-form */
 381         {as: AVOR, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},  /* vector or, vx-form */
 382
 383         /* Vector add */
 384         {as: AVADDUM, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},            /* vector add unsigned modulo, vx-form */
 385         {as: AVADDCU, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},            /* vector add & write carry unsigned, vx-form */
 386         {as: AVADDUS, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},            /* vector add unsigned saturate, vx-form */
 387         {as: AVADDSS, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},            /* vector add signed saturate, vx-form */
 388         {as: AVADDE, a1: C_VREG, a2: C_VREG, a3: C_VREG, a6: C_VREG, type_: 83, size: 4}, /* vector add extended, va-form */
 389
 390         /* Vector subtract */
 391         {as: AVSUBUM, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},            /* vector subtract unsigned modulo, vx-form */
 392         {as: AVSUBCU, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},            /* vector subtract & write carry unsigned, vx-form */
 393         {as: AVSUBUS, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},            /* vector subtract unsigned saturate, vx-form */
 394         {as: AVSUBSS, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},            /* vector subtract signed saturate, vx-form */
 395         {as: AVSUBE, a1: C_VREG, a2: C_VREG, a3: C_VREG, a6: C_VREG, type_: 83, size: 4}, /* vector subtract extended, va-form */
 396
 397         /* Vector multiply */
 398         {as: AVMULESB, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},              /* vector multiply, vx-form */
 399         {as: AVPMSUM, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},               /* vector polynomial multiply & sum, vx-form */
 400         {as: AVMSUMUDM, a1: C_VREG, a2: C_VREG, a3: C_VREG, a6: C_VREG, type_: 83, size: 4}, /* vector multiply-sum, va-form */
 401
 402         /* Vector rotate */
 403         {as: AVR, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4}, /* vector rotate, vx-form */
 404
 405         /* Vector shift */
 406         {as: AVS, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},                 /* vector shift, vx-form */
 407         {as: AVSA, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},                /* vector shift algebraic, vx-form */
 408         {as: AVSOI, a1: C_ANDCON, a2: C_VREG, a3: C_VREG, a6: C_VREG, type_: 83, size: 4}, /* vector shift by octet immediate, va-form */
 409
 410         /* Vector count */
 411         {as: AVCLZ, a1: C_VREG, a6: C_VREG, type_: 85, size: 4},    /* vector count leading zeros, vx-form */
 412         {as: AVPOPCNT, a1: C_VREG, a6: C_VREG, type_: 85, size: 4}, /* vector population count, vx-form */
 413
 414         /* Vector compare */
 415         {as: AVCMPEQ, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},   /* vector compare equal, vc-form */
 416         {as: AVCMPGT, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},   /* vector compare greater than, vc-form */
 417         {as: AVCMPNEZB, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4}, /* vector compare not equal, vx-form */
 418
 419         /* Vector merge */
 420         {as: AVMRGOW, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4}, /* vector merge odd word, vx-form */
 421
 422         /* Vector permute */
 423         {as: AVPERM, a1: C_VREG, a2: C_VREG, a3: C_VREG, a6: C_VREG, type_: 83, size: 4}, /* vector permute, va-form */
 424
 425         /* Vector bit permute */
 426         {as: AVBPERMQ, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4}, /* vector bit permute, vx-form */
 427
 428         /* Vector select */
 429         {as: AVSEL, a1: C_VREG, a2: C_VREG, a3: C_VREG, a6: C_VREG, type_: 83, size: 4}, /* vector select, va-form */
 430
 431         /* Vector splat */
 432         {as: AVSPLTB, a1: C_SCON, a2: C_VREG, a6: C_VREG, type_: 82, size: 4}, /* vector splat, vx-form */
 433         {as: AVSPLTB, a1: C_ADDCON, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},
 434         {as: AVSPLTISB, a1: C_SCON, a6: C_VREG, type_: 82, size: 4}, /* vector splat immediate, vx-form */
 435         {as: AVSPLTISB, a1: C_ADDCON, a6: C_VREG, type_: 82, size: 4},
 436
 437         /* Vector AES */
 438         {as: AVCIPH, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4},  /* vector AES cipher, vx-form */
 439         {as: AVNCIPH, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4}, /* vector AES inverse cipher, vx-form */
 440         {as: AVSBOX, a1: C_VREG, a6: C_VREG, type_: 82, size: 4},              /* vector AES subbytes, vx-form */
 441
 442         /* Vector SHA */
 443         {as: AVSHASIGMA, a1: C_ANDCON, a2: C_VREG, a3: C_ANDCON, a6: C_VREG, type_: 82, size: 4}, /* vector SHA sigma, vx-form */
 444
 445         /* VSX vector load */
 446         {as: ALXVD2X, a1: C_SOREG, a6: C_VSREG, type_: 87, size: 4},        /* vsx vector load, xx1-form */
 447         {as: ALXV, a1: C_SOREG, a6: C_VSREG, type_: 96, size: 4},           /* vsx vector load, dq-form */
 448         {as: ALXVL, a1: C_REG, a2: C_REG, a6: C_VSREG, type_: 98, size: 4}, /* vsx vector load length */
 449
 450         /* VSX vector store */
 451         {as: ASTXVD2X, a1: C_VSREG, a6: C_SOREG, type_: 86, size: 4},        /* vsx vector store, xx1-form */
 452         {as: ASTXV, a1: C_VSREG, a6: C_SOREG, type_: 97, size: 4},           /* vsx vector store, dq-form */
 453         {as: ASTXVL, a1: C_VSREG, a2: C_REG, a6: C_REG, type_: 99, size: 4}, /* vsx vector store with length x-form */
 454
 455         /* VSX scalar load */
 456         {as: ALXSDX, a1: C_SOREG, a6: C_VSREG, type_: 87, size: 4}, /* vsx scalar load, xx1-form */
 457
 458         /* VSX scalar store */
 459         {as: ASTXSDX, a1: C_VSREG, a6: C_SOREG, type_: 86, size: 4}, /* vsx scalar store, xx1-form */
 460
 461         /* VSX scalar as integer load */
 462         {as: ALXSIWAX, a1: C_SOREG, a6: C_VSREG, type_: 87, size: 4}, /* vsx scalar as integer load, xx1-form */
 463
 464         /* VSX scalar store as integer */
 465         {as: ASTXSIWX, a1: C_VSREG, a6: C_SOREG, type_: 86, size: 4}, /* vsx scalar as integer store, xx1-form */
 466
 467         /* VSX move from VSR */
 468         {as: AMFVSRD, a1: C_VSREG, a6: C_REG, type_: 88, size: 4}, /* vsx move from vsr, xx1-form */
 469         {as: AMFVSRD, a1: C_FREG, a6: C_REG, type_: 88, size: 4},
 470         {as: AMFVSRD, a1: C_VREG, a6: C_REG, type_: 88, size: 4},
 471
 472         /* VSX move to VSR */
 473         {as: AMTVSRD, a1: C_REG, a6: C_VSREG, type_: 88, size: 4}, /* vsx move to vsr, xx1-form */
 474         {as: AMTVSRD, a1: C_REG, a2: C_REG, a6: C_VSREG, type_: 88, size: 4},
 475         {as: AMTVSRD, a1: C_REG, a6: C_FREG, type_: 88, size: 4},
 476         {as: AMTVSRD, a1: C_REG, a6: C_VREG, type_: 88, size: 4},
 477
 478         /* VSX logical */
 479         {as: AXXLAND, a1: C_VSREG, a2: C_VSREG, a6: C_VSREG, type_: 90, size: 4}, /* vsx and, xx3-form */
 480         {as: AXXLOR, a1: C_VSREG, a2: C_VSREG, a6: C_VSREG, type_: 90, size: 4},  /* vsx or, xx3-form */
 481
 482         /* VSX select */
 483         {as: AXXSEL, a1: C_VSREG, a2: C_VSREG, a3: C_VSREG, a6: C_VSREG, type_: 91, size: 4}, /* vsx select, xx4-form */
 484
 485         /* VSX merge */
 486         {as: AXXMRGHW, a1: C_VSREG, a2: C_VSREG, a6: C_VSREG, type_: 90, size: 4}, /* vsx merge, xx3-form */
 487
 488         /* VSX splat */
 489         {as: AXXSPLTW, a1: C_VSREG, a3: C_SCON, a6: C_VSREG, type_: 89, size: 4}, /* vsx splat, xx2-form */
 490         {as: AXXSPLTIB, a1: C_SCON, a6: C_VSREG, type_: 100, size: 4},            /* vsx splat, xx2-form */
 491
 492         /* VSX permute */
 493         {as: AXXPERM, a1: C_VSREG, a2: C_VSREG, a6: C_VSREG, type_: 90, size: 4}, /* vsx permute, xx3-form */
 494
 495         /* VSX shift */
 496         {as: AXXSLDWI, a1: C_VSREG, a2: C_VSREG, a3: C_SCON, a6: C_VSREG, type_: 90, size: 4}, /* vsx shift immediate, xx3-form */
 497
 498         /* VSX reverse bytes */
 499         {as: AXXBRQ, a1: C_VSREG, a6: C_VSREG, type_: 101, size: 4}, /* vsx reverse bytes */
 500
 501         /* VSX scalar FP-FP conversion */
 502         {as: AXSCVDPSP, a1: C_VSREG, a6: C_VSREG, type_: 89, size: 4}, /* vsx scalar fp-fp conversion, xx2-form */
 503
 504         /* VSX vector FP-FP conversion */
 505         {as: AXVCVDPSP, a1: C_VSREG, a6: C_VSREG, type_: 89, size: 4}, /* vsx vector fp-fp conversion, xx2-form */
 506
 507         /* VSX scalar FP-integer conversion */
 508         {as: AXSCVDPSXDS, a1: C_VSREG, a6: C_VSREG, type_: 89, size: 4}, /* vsx scalar fp-integer conversion, xx2-form */
 509
 510         /* VSX scalar integer-FP conversion */
 511         {as: AXSCVSXDDP, a1: C_VSREG, a6: C_VSREG, type_: 89, size: 4}, /* vsx scalar integer-fp conversion, xx2-form */
 512
 513         /* VSX vector FP-integer conversion */
 514         {as: AXVCVDPSXDS, a1: C_VSREG, a6: C_VSREG, type_: 89, size: 4}, /* vsx vector fp-integer conversion, xx2-form */
 515
 516         /* VSX vector integer-FP conversion */
 517         {as: AXVCVSXDDP, a1: C_VSREG, a6: C_VSREG, type_: 89, size: 4}, /* vsx vector integer-fp conversion, xx2-form */
 518
 519         {as: ACMP, a1: C_REG, a6: C_REG, type_: 70, size: 4},
 520         {as: ACMP, a1: C_REG, a2: C_REG, a6: C_REG, type_: 70, size: 4},
 521         {as: ACMP, a1: C_REG, a6: C_ADDCON, type_: 71, size: 4},
 522         {as: ACMP, a1: C_REG, a2: C_REG, a6: C_ADDCON, type_: 71, size: 4},
 523         {as: ACMPU, a1: C_REG, a6: C_REG, type_: 70, size: 4},
 524         {as: ACMPU, a1: C_REG, a2: C_REG, a6: C_REG, type_: 70, size: 4},
 525         {as: ACMPU, a1: C_REG, a6: C_ANDCON, type_: 71, size: 4},
 526         {as: ACMPU, a1: C_REG, a2: C_REG, a6: C_ANDCON, type_: 71, size: 4},
 527         {as: AFCMPO, a1: C_FREG, a6: C_FREG, type_: 70, size: 4},
 528         {as: AFCMPO, a1: C_FREG, a2: C_REG, a6: C_FREG, type_: 70, size: 4},
 529         {as: ATW, a1: C_LCON, a2: C_REG, a6: C_REG, type_: 60, size: 4},
 530         {as: ATW, a1: C_LCON, a2: C_REG, a6: C_ADDCON, type_: 61, size: 4},
 531         {as: ADCBF, a1: C_ZOREG, type_: 43, size: 4},
 532         {as: ADCBF, a1: C_SOREG, type_: 43, size: 4},
 533         {as: ADCBF, a1: C_ZOREG, a2: C_REG, a6: C_SCON, type_: 43, size: 4},
 534         {as: ADCBF, a1: C_SOREG, a6: C_SCON, type_: 43, size: 4},
 535         {as: AECOWX, a1: C_REG, a2: C_REG, a6: C_ZOREG, type_: 44, size: 4},
 536         {as: AECIWX, a1: C_ZOREG, a2: C_REG, a6: C_REG, type_: 45, size: 4},
 537         {as: AECOWX, a1: C_REG, a6: C_ZOREG, type_: 44, size: 4},
 538         {as: AECIWX, a1: C_ZOREG, a6: C_REG, type_: 45, size: 4},
 539         {as: ALDAR, a1: C_ZOREG, a6: C_REG, type_: 45, size: 4},
 540         {as: ALDAR, a1: C_ZOREG, a3: C_ANDCON, a6: C_REG, type_: 45, size: 4},
 541         {as: AEIEIO, type_: 46, size: 4},
 542         {as: ATLBIE, a1: C_REG, type_: 49, size: 4},
 543         {as: ATLBIE, a1: C_SCON, a6: C_REG, type_: 49, size: 4},
 544         {as: ASLBMFEE, a1: C_REG, a6: C_REG, type_: 55, size: 4},
 545         {as: ASLBMTE, a1: C_REG, a6: C_REG, type_: 55, size: 4},
 546         {as: ASTSW, a1: C_REG, a6: C_ZOREG, type_: 44, size: 4},
 547         {as: ASTSW, a1: C_REG, a3: C_LCON, a6: C_ZOREG, type_: 41, size: 4},
 548         {as: ALSW, a1: C_ZOREG, a6: C_REG, type_: 45, size: 4},
 549         {as: ALSW, a1: C_ZOREG, a3: C_LCON, a6: C_REG, type_: 42, size: 4},
 550         {as: obj.AUNDEF, type_: 78, size: 4},
 551         {as: obj.APCDATA, a1: C_LCON, a6: C_LCON, type_: 0, size: 0},
 552         {as: obj.AFUNCDATA, a1: C_SCON, a6: C_ADDR, type_: 0, size: 0},
 553         {as: obj.ANOP, type_: 0, size: 0},
 554         {as: obj.ANOP, a1: C_LCON, type_: 0, size: 0}, // NOP operand variations added for #40689
 555         {as: obj.ANOP, a1: C_REG, type_: 0, size: 0},  // to preserve previous behavior
 556         {as: obj.ANOP, a1: C_FREG, type_: 0, size: 0},
 557         {as: obj.ADUFFZERO, a6: C_LBRA, type_: 11, size: 4}, // same as ABR/ABL
 558         {as: obj.ADUFFCOPY, a6: C_LBRA, type_: 11, size: 4}, // same as ABR/ABL
 559         {as: obj.APCALIGN, a1: C_LCON, type_: 0, size: 0},   // align code
 560
 561         {as: obj.AXXX, type_: 0, size: 4},
 562 }
 563
 564 var oprange [ALAST & obj.AMask][]Optab
 565
 566 var xcmp [C_NCLASS][C_NCLASS]bool
 567
 568 // padding bytes to add to align code as requested
 569 func addpad(pc, a int64, ctxt *obj.Link, cursym *obj.LSym) int {
 570         // For 16 and 32 byte alignment, there is a tradeoff
 571         // between aligning the code and adding too many NOPs.
 572         switch a {
 573         case 8:
 574                 if pc&7 != 0 {
 575                         return 4
 576                 }
 577         case 16:
 578                 // Align to 16 bytes if possible but add at
 579                 // most 2 NOPs.
 580                 switch pc & 15 {
 581                 case 4, 12:
 582                         return 4
 583                 case 8:
 584                         return 8
 585                 }
 586         case 32:
 587                 // Align to 32 bytes if possible but add at
 588                 // most 3 NOPs.
 589                 switch pc & 31 {
 590                 case 4, 20:
 591                         return 12
 592                 case 8, 24:
 593                         return 8
 594                 case 12, 28:
 595                         return 4
 596                 }
 597                 // When 32 byte alignment is requested on Linux,
 598                 // promote the function's alignment to 32. On AIX
 599                 // the function alignment is not changed which might
 600                 // result in 16 byte alignment but that is still fine.
 601                 // TODO: alignment on AIX
 602                 if ctxt.Headtype != objabi.Haix && cursym.Func().Align < 32 {
 603                         cursym.Func().Align = 32
 604                 }
 605         default:
 606                 ctxt.Diag("Unexpected alignment: %d for PCALIGN directive\n", a)
 607         }
 608         return 0
 609 }
 610
 611 // Get the implied register of a operand which doesn't specify one.  These show up
 612 // in handwritten asm like "MOVD R5, foosymbol" where a base register is not supplied,
 613 // or "MOVD R5, foo+10(SP) or pseudo-register is used.  The other common case is when
 614 // generating constants in register like "MOVD $constant, Rx".
 615 func (c *ctxt9) getimpliedreg(a *obj.Addr, p *obj.Prog) int {
 616         switch oclass(a) {
 617         case C_ADDCON, C_ANDCON, C_UCON, C_LCON, C_SCON, C_ZCON:
 618                 return REGZERO
 619         case C_SECON, C_LECON:
 620                 return REGSB
 621         case C_SACON, C_LACON:
 622                 return REGSP
 623         case C_LOREG, C_SOREG, C_ZOREG:
 624                 switch a.Name {
 625                 case obj.NAME_EXTERN, obj.NAME_STATIC:
 626                         return REGSB
 627                 case obj.NAME_AUTO, obj.NAME_PARAM:
 628                         return REGSP
 629                 case obj.NAME_NONE:
 630                         return REGZERO
 631                 }
 632         }
 633         c.ctxt.Diag("failed to determine implied reg for class %v (%v)", DRconv(oclass(a)), p)
 634         return 0
 635 }
 636
 637 func span9(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 638         p := cursym.Func().Text
 639         if p == nil || p.Link == nil { // handle external functions and ELF section symbols
 640                 return
 641         }
 642
 643         if oprange[AANDN&obj.AMask] == nil {
 644                 ctxt.Diag("ppc64 ops not initialized, call ppc64.buildop first")
 645         }
 646
 647         c := ctxt9{ctxt: ctxt, newprog: newprog, cursym: cursym, autosize: int32(p.To.Offset)}
 648
 649         pc := int64(0)
 650         p.Pc = pc
 651
 652         var m int
 653         var o *Optab
 654         for p = p.Link; p != nil; p = p.Link {
 655                 p.Pc = pc
 656                 o = c.oplook(p)
 657                 m = int(o.size)
 658                 if m == 0 {
 659                         if p.As == obj.APCALIGN {
 660                                 a := c.vregoff(&p.From)
 661                                 m = addpad(pc, a, ctxt, cursym)
 662                         } else {
 663                                 if p.As != obj.ANOP && p.As != obj.AFUNCDATA && p.As != obj.APCDATA {
 664                                         ctxt.Diag("zero-width instruction\n%v", p)
 665                                 }
 666                                 continue
 667                         }
 668                 }
 669                 pc += int64(m)
 670         }
 671
 672         c.cursym.Size = pc
 673
 674         /*
 675          * if any procedure is large enough to
 676          * generate a large SBRA branch, then
 677          * generate extra passes putting branches
 678          * around jmps to fix. this is rare.
 679          */
 680         bflag := 1
 681
 682         var otxt int64
 683         var q *obj.Prog
 684         for bflag != 0 {
 685                 bflag = 0
 686                 pc = 0
 687                 for p = c.cursym.Func().Text.Link; p != nil; p = p.Link {
 688                         p.Pc = pc
 689                         o = c.oplook(p)
 690
 691                         // very large conditional branches
 692                         if (o.type_ == 16 || o.type_ == 17) && p.To.Target() != nil {
 693                                 otxt = p.To.Target().Pc - pc
 694                                 if otxt < -(1<<15)+10 || otxt >= (1<<15)-10 {
 695                                         q = c.newprog()
 696                                         q.Link = p.Link
 697                                         p.Link = q
 698                                         q.As = ABR
 699                                         q.To.Type = obj.TYPE_BRANCH
 700                                         q.To.SetTarget(p.To.Target())
 701                                         p.To.SetTarget(q)
 702                                         q = c.newprog()
 703                                         q.Link = p.Link
 704                                         p.Link = q
 705                                         q.As = ABR
 706                                         q.To.Type = obj.TYPE_BRANCH
 707                                         q.To.SetTarget(q.Link.Link)
 708
 709                                         //addnop(p->link);
 710                                         //addnop(p);
 711                                         bflag = 1
 712                                 }
 713                         }
 714
 715                         m = int(o.size)
 716                         if m == 0 {
 717                                 if p.As == obj.APCALIGN {
 718                                         a := c.vregoff(&p.From)
 719                                         m = addpad(pc, a, ctxt, cursym)
 720                                 } else {
 721                                         if p.As != obj.ANOP && p.As != obj.AFUNCDATA && p.As != obj.APCDATA {
 722                                                 ctxt.Diag("zero-width instruction\n%v", p)
 723                                         }
 724                                         continue
 725                                 }
 726                         }
 727
 728                         pc += int64(m)
 729                 }
 730
 731                 c.cursym.Size = pc
 732         }
 733
 734         if r := pc & funcAlignMask; r != 0 {
 735                 pc += funcAlign - r
 736         }
 737
 738         c.cursym.Size = pc
 739
 740         /*
 741          * lay out the code, emitting code and data relocations.
 742          */
 743
 744         c.cursym.Grow(c.cursym.Size)
 745
 746         bp := c.cursym.P
 747         var i int32
 748         var out [6]uint32
 749         for p := c.cursym.Func().Text.Link; p != nil; p = p.Link {
 750                 c.pc = p.Pc
 751                 o = c.oplook(p)
 752                 if int(o.size) > 4*len(out) {
 753                         log.Fatalf("out array in span9 is too small, need at least %d for %v", o.size/4, p)
 754                 }
 755                 // asmout is not set up to add large amounts of padding
 756                 if o.type_ == 0 && p.As == obj.APCALIGN {
 757                         pad := LOP_RRR(OP_OR, REGZERO, REGZERO, REGZERO)
 758                         aln := c.vregoff(&p.From)
 759                         v := addpad(p.Pc, aln, c.ctxt, c.cursym)
 760                         if v > 0 {
 761                                 // Same padding instruction for all
 762                                 for i = 0; i < int32(v/4); i++ {
 763                                         c.ctxt.Arch.ByteOrder.PutUint32(bp, pad)
 764                                         bp = bp[4:]
 765                                 }
 766                         }
 767                 } else {
 768                         c.asmout(p, o, out[:])
 769                         for i = 0; i < int32(o.size/4); i++ {
 770                                 c.ctxt.Arch.ByteOrder.PutUint32(bp, out[i])
 771                                 bp = bp[4:]
 772                         }
 773                 }
 774         }
 775 }
 776
 777 func isint32(v int64) bool {
 778         return int64(int32(v)) == v
 779 }
 780
 781 func isuint32(v uint64) bool {
 782         return uint64(uint32(v)) == v
 783 }
 784
 785 func (c *ctxt9) aclass(a *obj.Addr) int {
 786         switch a.Type {
 787         case obj.TYPE_NONE:
 788                 return C_NONE
 789
 790         case obj.TYPE_REG:
 791                 if REG_R0 <= a.Reg && a.Reg <= REG_R31 {
 792                         return C_REG
 793                 }
 794                 if REG_F0 <= a.Reg && a.Reg <= REG_F31 {
 795                         return C_FREG
 796                 }
 797                 if REG_V0 <= a.Reg && a.Reg <= REG_V31 {
 798                         return C_VREG
 799                 }
 800                 if REG_VS0 <= a.Reg && a.Reg <= REG_VS63 {
 801                         return C_VSREG
 802                 }
 803                 if REG_CR0 <= a.Reg && a.Reg <= REG_CR7 || a.Reg == REG_CR {
 804                         return C_CREG
 805                 }
 806                 if REG_SPR0 <= a.Reg && a.Reg <= REG_SPR0+1023 {
 807                         switch a.Reg {
 808                         case REG_LR:
 809                                 return C_LR
 810
 811                         case REG_XER:
 812                                 return C_XER
 813
 814                         case REG_CTR:
 815                                 return C_CTR
 816                         }
 817
 818                         return C_SPR
 819                 }
 820
 821                 if REG_DCR0 <= a.Reg && a.Reg <= REG_DCR0+1023 {
 822                         return C_SPR
 823                 }
 824                 if a.Reg == REG_FPSCR {
 825                         return C_FPSCR
 826                 }
 827                 if a.Reg == REG_MSR {
 828                         return C_MSR
 829                 }
 830                 return C_GOK
 831
 832         case obj.TYPE_MEM:
 833                 switch a.Name {
 834                 case obj.NAME_EXTERN,
 835                         obj.NAME_STATIC:
 836                         if a.Sym == nil {
 837                                 break
 838                         }
 839                         c.instoffset = a.Offset
 840                         if a.Sym != nil { // use relocation
 841                                 if a.Sym.Type == objabi.STLSBSS {
 842                                         if c.ctxt.Flag_shared {
 843                                                 return C_TLS_IE
 844                                         } else {
 845                                                 return C_TLS_LE
 846                                         }
 847                                 }
 848                                 return C_ADDR
 849                         }
 850                         return C_LOREG
 851
 852                 case obj.NAME_GOTREF:
 853                         return C_GOTADDR
 854
 855                 case obj.NAME_TOCREF:
 856                         return C_TOCADDR
 857
 858                 case obj.NAME_AUTO:
 859                         c.instoffset = int64(c.autosize) + a.Offset
 860                         if c.instoffset >= -BIG && c.instoffset < BIG {
 861                                 return C_SOREG
 862                         }
 863                         return C_LOREG
 864
 865                 case obj.NAME_PARAM:
 866                         c.instoffset = int64(c.autosize) + a.Offset + c.ctxt.FixedFrameSize()
 867                         if c.instoffset >= -BIG && c.instoffset < BIG {
 868                                 return C_SOREG
 869                         }
 870                         return C_LOREG
 871
 872                 case obj.NAME_NONE:
 873                         c.instoffset = a.Offset
 874                         if c.instoffset == 0 {
 875                                 return C_ZOREG
 876                         }
 877                         if c.instoffset >= -BIG && c.instoffset < BIG {
 878                                 return C_SOREG
 879                         }
 880                         return C_LOREG
 881                 }
 882
 883                 return C_GOK
 884
 885         case obj.TYPE_TEXTSIZE:
 886                 return C_TEXTSIZE
 887
 888         case obj.TYPE_FCONST:
 889                 // The only cases where FCONST will occur are with float64 +/- 0.
 890                 // All other float constants are generated in memory.
 891                 f64 := a.Val.(float64)
 892                 if f64 == 0 {
 893                         if math.Signbit(f64) {
 894                                 return C_ADDCON
 895                         }
 896                         return C_ZCON
 897                 }
 898                 log.Fatalf("Unexpected nonzero FCONST operand %v", a)
 899
 900         case obj.TYPE_CONST,
 901                 obj.TYPE_ADDR:
 902                 switch a.Name {
 903                 case obj.NAME_NONE:
 904                         c.instoffset = a.Offset
 905                         if a.Reg != 0 {
 906                                 if -BIG <= c.instoffset && c.instoffset <= BIG {
 907                                         return C_SACON
 908                                 }
 909                                 if isint32(c.instoffset) {
 910                                         return C_LACON
 911                                 }
 912                                 return C_DACON
 913                         }
 914
 915                 case obj.NAME_EXTERN,
 916                         obj.NAME_STATIC:
 917                         s := a.Sym
 918                         if s == nil {
 919                                 return C_GOK
 920                         }
 921
 922                         c.instoffset = a.Offset
 923
 924                         /* not sure why this barfs */
 925                         return C_LCON
 926
 927                 case obj.NAME_AUTO:
 928                         c.instoffset = int64(c.autosize) + a.Offset
 929                         if c.instoffset >= -BIG && c.instoffset < BIG {
 930                                 return C_SACON
 931                         }
 932                         return C_LACON
 933
 934                 case obj.NAME_PARAM:
 935                         c.instoffset = int64(c.autosize) + a.Offset + c.ctxt.FixedFrameSize()
 936                         if c.instoffset >= -BIG && c.instoffset < BIG {
 937                                 return C_SACON
 938                         }
 939                         return C_LACON
 940
 941                 default:
 942                         return C_GOK
 943                 }
 944
 945                 if c.instoffset >= 0 {
 946                         if c.instoffset == 0 {
 947                                 return C_ZCON
 948                         }
 949                         if c.instoffset <= 0x7fff {
 950                                 return C_SCON
 951                         }
 952                         if c.instoffset <= 0xffff {
 953                                 return C_ANDCON
 954                         }
 955                         if c.instoffset&0xffff == 0 && isuint32(uint64(c.instoffset)) { /* && (instoffset & (1<<31)) == 0) */
 956                                 return C_UCON
 957                         }
 958                         if isint32(c.instoffset) || isuint32(uint64(c.instoffset)) {
 959                                 return C_LCON
 960                         }
 961                         return C_DCON
 962                 }
 963
 964                 if c.instoffset >= -0x8000 {
 965                         return C_ADDCON
 966                 }
 967                 if c.instoffset&0xffff == 0 && isint32(c.instoffset) {
 968                         return C_UCON
 969                 }
 970                 if isint32(c.instoffset) {
 971                         return C_LCON
 972                 }
 973                 return C_DCON
 974
 975         case obj.TYPE_BRANCH:
 976                 if a.Sym != nil && c.ctxt.Flag_dynlink {
 977                         return C_LBRAPIC
 978                 }
 979                 return C_SBRA
 980         }
 981
 982         return C_GOK
 983 }
 984
 985 func prasm(p *obj.Prog) {
 986         fmt.Printf("%v\n", p)
 987 }
 988
 989 func (c *ctxt9) oplook(p *obj.Prog) *Optab {
 990         a1 := int(p.Optab)
 991         if a1 != 0 {
 992                 return &optab[a1-1]
 993         }
 994         a1 = int(p.From.Class)
 995         if a1 == 0 {
 996                 a1 = c.aclass(&p.From) + 1
 997                 p.From.Class = int8(a1)
 998         }
 999         a1--
1000
1001         argsv := [3]int{C_NONE + 1, C_NONE + 1, C_NONE + 1}
1002         for i, ap := range p.RestArgs {
1003                 argsv[i] = int(ap.Addr.Class)
1004                 if argsv[i] == 0 {
1005                         argsv[i] = c.aclass(&ap.Addr) + 1
1006                         ap.Addr.Class = int8(argsv[i])
1007                 }
1008
1009         }
1010         a3 := argsv[0] - 1
1011         a4 := argsv[1] - 1
1012         a5 := argsv[2] - 1
1013
1014         a6 := int(p.To.Class)
1015         if a6 == 0 {
1016                 a6 = c.aclass(&p.To) + 1
1017                 p.To.Class = int8(a6)
1018         }
1019         a6--
1020
1021         a2 := C_NONE
1022         if p.Reg != 0 {
1023                 if REG_R0 <= p.Reg && p.Reg <= REG_R31 {
1024                         a2 = C_REG
1025                 } else if REG_V0 <= p.Reg && p.Reg <= REG_V31 {
1026                         a2 = C_VREG
1027                 } else if REG_VS0 <= p.Reg && p.Reg <= REG_VS63 {
1028                         a2 = C_VSREG
1029                 } else if REG_F0 <= p.Reg && p.Reg <= REG_F31 {
1030                         a2 = C_FREG
1031                 }
1032         }
1033
1034         // c.ctxt.Logf("oplook %v %d %d %d %d\n", p, a1, a2, a3, a4, a5, a6)
1035         ops := oprange[p.As&obj.AMask]
1036         c1 := &xcmp[a1]
1037         c3 := &xcmp[a3]
1038         c4 := &xcmp[a4]
1039         c5 := &xcmp[a5]
1040         c6 := &xcmp[a6]
1041         for i := range ops {
1042                 op := &ops[i]
1043                 if int(op.a2) == a2 && c1[op.a1] && c3[op.a3] && c4[op.a4] && c5[op.a5] && c6[op.a6] {
1044                         p.Optab = uint16(cap(optab) - cap(ops) + i + 1)
1045                         return op
1046                 }
1047         }
1048
1049         c.ctxt.Diag("illegal combination %v %v %v %v %v %v %v", p.As, DRconv(a1), DRconv(a2), DRconv(a3), DRconv(a4), DRconv(a5), DRconv(a6))
1050         prasm(p)
1051         if ops == nil {
1052                 ops = optab
1053         }
1054         return &ops[0]
1055 }
1056
1057 func cmp(a int, b int) bool {
1058         if a == b {
1059                 return true
1060         }
1061         switch a {
1062         case C_LCON:
1063                 if b == C_ZCON || b == C_SCON || b == C_UCON || b == C_ADDCON || b == C_ANDCON {
1064                         return true
1065                 }
1066
1067         case C_ADDCON:
1068                 if b == C_ZCON || b == C_SCON {
1069                         return true
1070                 }
1071
1072         case C_ANDCON:
1073                 if b == C_ZCON || b == C_SCON {
1074                         return true
1075                 }
1076
1077         case C_SPR:
1078                 if b == C_LR || b == C_XER || b == C_CTR {
1079                         return true
1080                 }
1081
1082         case C_UCON:
1083                 if b == C_ZCON {
1084                         return true
1085                 }
1086
1087         case C_SCON:
1088                 if b == C_ZCON {
1089                         return true
1090                 }
1091
1092         case C_LACON:
1093                 if b == C_SACON {
1094                         return true
1095                 }
1096
1097         case C_LBRA:
1098                 if b == C_SBRA {
1099                         return true
1100                 }
1101
1102         case C_SOREG:
1103                 if b == C_ZOREG {
1104                         return true
1105                 }
1106
1107         case C_LOREG:
1108                 if b == C_SOREG || b == C_ZOREG {
1109                         return true
1110                 }
1111
1112         case C_REG:
1113                 if b == C_ZCON {
1114                         return r0iszero != 0 /*TypeKind(100016)*/
1115                 }
1116
1117         case C_ANY:
1118                 return true
1119         }
1120
1121         return false
1122 }
1123
1124 type ocmp []Optab
1125
1126 func (x ocmp) Len() int {
1127         return len(x)
1128 }
1129
1130 func (x ocmp) Swap(i, j int) {
1131         x[i], x[j] = x[j], x[i]
1132 }
1133
1134 // Used when sorting the optab. Sorting is
1135 // done in a way so that the best choice of
1136 // opcode/operand combination is considered first.
1137 func (x ocmp) Less(i, j int) bool {
1138         p1 := &x[i]
1139         p2 := &x[j]
1140         n := int(p1.as) - int(p2.as)
1141         // same opcode
1142         if n != 0 {
1143                 return n < 0
1144         }
1145         // Consider those that generate fewer
1146         // instructions first.
1147         n = int(p1.size) - int(p2.size)
1148         if n != 0 {
1149                 return n < 0
1150         }
1151         // operand order should match
1152         // better choices first
1153         n = int(p1.a1) - int(p2.a1)
1154         if n != 0 {
1155                 return n < 0
1156         }
1157         n = int(p1.a2) - int(p2.a2)
1158         if n != 0 {
1159                 return n < 0
1160         }
1161         n = int(p1.a3) - int(p2.a3)
1162         if n != 0 {
1163                 return n < 0
1164         }
1165         n = int(p1.a4) - int(p2.a4)
1166         if n != 0 {
1167                 return n < 0
1168         }
1169         n = int(p1.a5) - int(p2.a5)
1170         if n != 0 {
1171                 return n < 0
1172         }
1173         n = int(p1.a6) - int(p2.a6)
1174         if n != 0 {
1175                 return n < 0
1176         }
1177         return false
1178 }
1179
1180 // Add an entry to the opcode table for
1181 // a new opcode b0 with the same operand combinations
1182 // as opcode a.
1183 func opset(a, b0 obj.As) {
1184         oprange[a&obj.AMask] = oprange[b0]
1185 }
1186
1187 // Build the opcode table
1188 func buildop(ctxt *obj.Link) {
1189         if oprange[AANDN&obj.AMask] != nil {
1190                 // Already initialized; stop now.
1191                 // This happens in the cmd/asm tests,
1192                 // each of which re-initializes the arch.
1193                 return
1194         }
1195
1196         var n int
1197
1198         for i := 0; i < C_NCLASS; i++ {
1199                 for n = 0; n < C_NCLASS; n++ {
1200                         if cmp(n, i) {
1201                                 xcmp[i][n] = true
1202                         }
1203                 }
1204         }
1205         for n = 0; optab[n].as != obj.AXXX; n++ {
1206         }
1207         sort.Sort(ocmp(optab[:n]))
1208         for i := 0; i < n; i++ {
1209                 r := optab[i].as
1210                 r0 := r & obj.AMask
1211                 start := i
1212                 for optab[i].as == r {
1213                         i++
1214                 }
1215                 oprange[r0] = optab[start:i]
1216                 i--
1217
1218                 switch r {
1219                 default:
1220                         ctxt.Diag("unknown op in build: %v", r)
1221                         log.Fatalf("instruction missing from switch in asm9.go:buildop: %v", r)
1222
1223                 case ADCBF: /* unary indexed: op (b+a); op (b) */
1224                         opset(ADCBI, r0)
1225
1226                         opset(ADCBST, r0)
1227                         opset(ADCBT, r0)
1228                         opset(ADCBTST, r0)
1229                         opset(ADCBZ, r0)
1230                         opset(AICBI, r0)
1231
1232                 case AECOWX: /* indexed store: op s,(b+a); op s,(b) */
1233                         opset(ASTWCCC, r0)
1234                         opset(ASTHCCC, r0)
1235                         opset(ASTBCCC, r0)
1236                         opset(ASTDCCC, r0)
1237
1238                 case AREM: /* macro */
1239                         opset(AREM, r0)
1240
1241                 case AREMU:
1242                         opset(AREMU, r0)
1243
1244                 case AREMD:
1245                         opset(AREMDU, r0)
1246
1247                 case AMULLW:
1248                         opset(AMULLD, r0)
1249
1250                 case ADIVW: /* op Rb[,Ra],Rd */
1251                         opset(AMULHW, r0)
1252
1253                         opset(AMULHWCC, r0)
1254                         opset(AMULHWU, r0)
1255                         opset(AMULHWUCC, r0)
1256                         opset(AMULLWCC, r0)
1257                         opset(AMULLWVCC, r0)
1258                         opset(AMULLWV, r0)
1259                         opset(ADIVWCC, r0)
1260                         opset(ADIVWV, r0)
1261                         opset(ADIVWVCC, r0)
1262                         opset(ADIVWU, r0)
1263                         opset(ADIVWUCC, r0)
1264                         opset(ADIVWUV, r0)
1265                         opset(ADIVWUVCC, r0)
1266                         opset(AMODUD, r0)
1267                         opset(AMODUW, r0)
1268                         opset(AMODSD, r0)
1269                         opset(AMODSW, r0)
1270                         opset(AADDCC, r0)
1271                         opset(AADDCV, r0)
1272                         opset(AADDCVCC, r0)
1273                         opset(AADDV, r0)
1274                         opset(AADDVCC, r0)
1275                         opset(AADDE, r0)
1276                         opset(AADDECC, r0)
1277                         opset(AADDEV, r0)
1278                         opset(AADDEVCC, r0)
1279                         opset(AMULHD, r0)
1280                         opset(AMULHDCC, r0)
1281                         opset(AMULHDU, r0)
1282                         opset(AMULHDUCC, r0)
1283                         opset(AMULLDCC, r0)
1284                         opset(AMULLDVCC, r0)
1285                         opset(AMULLDV, r0)
1286                         opset(ADIVD, r0)
1287                         opset(ADIVDCC, r0)
1288                         opset(ADIVDE, r0)
1289                         opset(ADIVDEU, r0)
1290                         opset(ADIVDECC, r0)
1291                         opset(ADIVDEUCC, r0)
1292                         opset(ADIVDVCC, r0)
1293                         opset(ADIVDV, r0)
1294                         opset(ADIVDU, r0)
1295                         opset(ADIVDUV, r0)
1296                         opset(ADIVDUVCC, r0)
1297                         opset(ADIVDUCC, r0)
1298
1299                 case ACRAND:
1300                         opset(ACRANDN, r0)
1301                         opset(ACREQV, r0)
1302                         opset(ACRNAND, r0)
1303                         opset(ACRNOR, r0)
1304                         opset(ACROR, r0)
1305                         opset(ACRORN, r0)
1306                         opset(ACRXOR, r0)
1307
1308                 case APOPCNTD: /* popcntd, popcntw, popcntb, cnttzw, cnttzd */
1309                         opset(APOPCNTW, r0)
1310                         opset(APOPCNTB, r0)
1311                         opset(ACNTTZW, r0)
1312                         opset(ACNTTZWCC, r0)
1313                         opset(ACNTTZD, r0)
1314                         opset(ACNTTZDCC, r0)
1315
1316                 case ACOPY: /* copy, paste. */
1317                         opset(APASTECC, r0)
1318
1319                 case AMADDHD: /* maddhd, maddhdu, maddld */
1320                         opset(AMADDHDU, r0)
1321                         opset(AMADDLD, r0)
1322
1323                 case AMOVBZ: /* lbz, stz, rlwm(r/r), lhz, lha, stz, and x variants */
1324                         opset(AMOVH, r0)
1325                         opset(AMOVHZ, r0)
1326
1327                 case AMOVBZU: /* lbz[x]u, stb[x]u, lhz[x]u, lha[x]u, sth[u]x, ld[x]u, std[u]x */
1328                         opset(AMOVHU, r0)
1329
1330                         opset(AMOVHZU, r0)
1331                         opset(AMOVWU, r0)
1332                         opset(AMOVWZU, r0)
1333                         opset(AMOVDU, r0)
1334                         opset(AMOVMW, r0)
1335
1336                 case ALV: /* lvebx, lvehx, lvewx, lvx, lvxl, lvsl, lvsr */
1337                         opset(ALVEBX, r0)
1338                         opset(ALVEHX, r0)
1339                         opset(ALVEWX, r0)
1340                         opset(ALVX, r0)
1341                         opset(ALVXL, r0)
1342                         opset(ALVSL, r0)
1343                         opset(ALVSR, r0)
1344
1345                 case ASTV: /* stvebx, stvehx, stvewx, stvx, stvxl */
1346                         opset(ASTVEBX, r0)
1347                         opset(ASTVEHX, r0)
1348                         opset(ASTVEWX, r0)
1349                         opset(ASTVX, r0)
1350                         opset(ASTVXL, r0)
1351
1352                 case AVAND: /* vand, vandc, vnand */
1353                         opset(AVAND, r0)
1354                         opset(AVANDC, r0)
1355                         opset(AVNAND, r0)
1356
1357                 case AVMRGOW: /* vmrgew, vmrgow */
1358                         opset(AVMRGEW, r0)
1359
1360                 case AVOR: /* vor, vorc, vxor, vnor, veqv */
1361                         opset(AVOR, r0)
1362                         opset(AVORC, r0)
1363                         opset(AVXOR, r0)
1364                         opset(AVNOR, r0)
1365                         opset(AVEQV, r0)
1366
1367                 case AVADDUM: /* vaddubm, vadduhm, vadduwm, vaddudm, vadduqm */
1368                         opset(AVADDUBM, r0)
1369                         opset(AVADDUHM, r0)
1370                         opset(AVADDUWM, r0)
1371                         opset(AVADDUDM, r0)
1372                         opset(AVADDUQM, r0)
1373
1374                 case AVADDCU: /* vaddcuq, vaddcuw */
1375                         opset(AVADDCUQ, r0)
1376                         opset(AVADDCUW, r0)
1377
1378                 case AVADDUS: /* vaddubs, vadduhs, vadduws */
1379                         opset(AVADDUBS, r0)
1380                         opset(AVADDUHS, r0)
1381                         opset(AVADDUWS, r0)
1382
1383                 case AVADDSS: /* vaddsbs, vaddshs, vaddsws */
1384                         opset(AVADDSBS, r0)
1385                         opset(AVADDSHS, r0)
1386                         opset(AVADDSWS, r0)
1387
1388                 case AVADDE: /* vaddeuqm, vaddecuq */
1389                         opset(AVADDEUQM, r0)
1390                         opset(AVADDECUQ, r0)
1391
1392                 case AVSUBUM: /* vsububm, vsubuhm, vsubuwm, vsubudm, vsubuqm */
1393                         opset(AVSUBUBM, r0)
1394                         opset(AVSUBUHM, r0)
1395                         opset(AVSUBUWM, r0)
1396                         opset(AVSUBUDM, r0)
1397                         opset(AVSUBUQM, r0)
1398
1399                 case AVSUBCU: /* vsubcuq, vsubcuw */
1400                         opset(AVSUBCUQ, r0)
1401                         opset(AVSUBCUW, r0)
1402
1403                 case AVSUBUS: /* vsububs, vsubuhs, vsubuws */
1404                         opset(AVSUBUBS, r0)
1405                         opset(AVSUBUHS, r0)
1406                         opset(AVSUBUWS, r0)
1407
1408                 case AVSUBSS: /* vsubsbs, vsubshs, vsubsws */
1409                         opset(AVSUBSBS, r0)
1410                         opset(AVSUBSHS, r0)
1411                         opset(AVSUBSWS, r0)
1412
1413                 case AVSUBE: /* vsubeuqm, vsubecuq */
1414                         opset(AVSUBEUQM, r0)
1415                         opset(AVSUBECUQ, r0)
1416
1417                 case AVMULESB: /* vmulesb, vmulosb, vmuleub, vmuloub, vmulosh, vmulouh, vmulesw, vmulosw, vmuleuw, vmulouw, vmuluwm */
1418                         opset(AVMULOSB, r0)
1419                         opset(AVMULEUB, r0)
1420                         opset(AVMULOUB, r0)
1421                         opset(AVMULESH, r0)
1422                         opset(AVMULOSH, r0)
1423                         opset(AVMULEUH, r0)
1424                         opset(AVMULOUH, r0)
1425                         opset(AVMULESW, r0)
1426                         opset(AVMULOSW, r0)
1427                         opset(AVMULEUW, r0)
1428                         opset(AVMULOUW, r0)
1429                         opset(AVMULUWM, r0)
1430                 case AVPMSUM: /* vpmsumb, vpmsumh, vpmsumw, vpmsumd */
1431                         opset(AVPMSUMB, r0)
1432                         opset(AVPMSUMH, r0)
1433                         opset(AVPMSUMW, r0)
1434                         opset(AVPMSUMD, r0)
1435
1436                 case AVR: /* vrlb, vrlh, vrlw, vrld */
1437                         opset(AVRLB, r0)
1438                         opset(AVRLH, r0)
1439                         opset(AVRLW, r0)
1440                         opset(AVRLD, r0)
1441
1442                 case AVS: /* vs[l,r], vs[l,r]o, vs[l,r]b, vs[l,r]h, vs[l,r]w, vs[l,r]d */
1443                         opset(AVSLB, r0)
1444                         opset(AVSLH, r0)
1445                         opset(AVSLW, r0)
1446                         opset(AVSL, r0)
1447                         opset(AVSLO, r0)
1448                         opset(AVSRB, r0)
1449                         opset(AVSRH, r0)
1450                         opset(AVSRW, r0)
1451                         opset(AVSR, r0)
1452                         opset(AVSRO, r0)
1453                         opset(AVSLD, r0)
1454                         opset(AVSRD, r0)
1455
1456                 case AVSA: /* vsrab, vsrah, vsraw, vsrad */
1457                         opset(AVSRAB, r0)
1458                         opset(AVSRAH, r0)
1459                         opset(AVSRAW, r0)
1460                         opset(AVSRAD, r0)
1461
1462                 case AVSOI: /* vsldoi */
1463                         opset(AVSLDOI, r0)
1464
1465                 case AVCLZ: /* vclzb, vclzh, vclzw, vclzd */
1466                         opset(AVCLZB, r0)
1467                         opset(AVCLZH, r0)
1468                         opset(AVCLZW, r0)
1469                         opset(AVCLZD, r0)
1470
1471                 case AVPOPCNT: /* vpopcntb, vpopcnth, vpopcntw, vpopcntd */
1472                         opset(AVPOPCNTB, r0)
1473                         opset(AVPOPCNTH, r0)
1474                         opset(AVPOPCNTW, r0)
1475                         opset(AVPOPCNTD, r0)
1476
1477                 case AVCMPEQ: /* vcmpequb[.], vcmpequh[.], vcmpequw[.], vcmpequd[.] */
1478                         opset(AVCMPEQUB, r0)
1479                         opset(AVCMPEQUBCC, r0)
1480                         opset(AVCMPEQUH, r0)
1481                         opset(AVCMPEQUHCC, r0)
1482                         opset(AVCMPEQUW, r0)
1483                         opset(AVCMPEQUWCC, r0)
1484                         opset(AVCMPEQUD, r0)
1485                         opset(AVCMPEQUDCC, r0)
1486
1487                 case AVCMPGT: /* vcmpgt[u,s]b[.], vcmpgt[u,s]h[.], vcmpgt[u,s]w[.], vcmpgt[u,s]d[.] */
1488                         opset(AVCMPGTUB, r0)
1489                         opset(AVCMPGTUBCC, r0)
1490                         opset(AVCMPGTUH, r0)
1491                         opset(AVCMPGTUHCC, r0)
1492                         opset(AVCMPGTUW, r0)
1493                         opset(AVCMPGTUWCC, r0)
1494                         opset(AVCMPGTUD, r0)
1495                         opset(AVCMPGTUDCC, r0)
1496                         opset(AVCMPGTSB, r0)
1497                         opset(AVCMPGTSBCC, r0)
1498                         opset(AVCMPGTSH, r0)
1499                         opset(AVCMPGTSHCC, r0)
1500                         opset(AVCMPGTSW, r0)
1501                         opset(AVCMPGTSWCC, r0)
1502                         opset(AVCMPGTSD, r0)
1503                         opset(AVCMPGTSDCC, r0)
1504
1505                 case AVCMPNEZB: /* vcmpnezb[.] */
1506                         opset(AVCMPNEZBCC, r0)
1507                         opset(AVCMPNEB, r0)
1508                         opset(AVCMPNEBCC, r0)
1509                         opset(AVCMPNEH, r0)
1510                         opset(AVCMPNEHCC, r0)
1511                         opset(AVCMPNEW, r0)
1512                         opset(AVCMPNEWCC, r0)
1513
1514                 case AVPERM: /* vperm */
1515                         opset(AVPERMXOR, r0)
1516                         opset(AVPERMR, r0)
1517
1518                 case AVBPERMQ: /* vbpermq, vbpermd */
1519                         opset(AVBPERMD, r0)
1520
1521                 case AVSEL: /* vsel */
1522                         opset(AVSEL, r0)
1523
1524                 case AVSPLTB: /* vspltb, vsplth, vspltw */
1525                         opset(AVSPLTH, r0)
1526                         opset(AVSPLTW, r0)
1527
1528                 case AVSPLTISB: /* vspltisb, vspltish, vspltisw */
1529                         opset(AVSPLTISH, r0)
1530                         opset(AVSPLTISW, r0)
1531
1532                 case AVCIPH: /* vcipher, vcipherlast */
1533                         opset(AVCIPHER, r0)
1534                         opset(AVCIPHERLAST, r0)
1535
1536                 case AVNCIPH: /* vncipher, vncipherlast */
1537                         opset(AVNCIPHER, r0)
1538                         opset(AVNCIPHERLAST, r0)
1539
1540                 case AVSBOX: /* vsbox */
1541                         opset(AVSBOX, r0)
1542
1543                 case AVSHASIGMA: /* vshasigmaw, vshasigmad */
1544                         opset(AVSHASIGMAW, r0)
1545                         opset(AVSHASIGMAD, r0)
1546
1547                 case ALXVD2X: /* lxvd2x, lxvdsx, lxvw4x, lxvh8x, lxvb16x */
1548                         opset(ALXVDSX, r0)
1549                         opset(ALXVW4X, r0)
1550                         opset(ALXVH8X, r0)
1551                         opset(ALXVB16X, r0)
1552
1553                 case ALXV: /* lxv */
1554                         opset(ALXV, r0)
1555
1556                 case ALXVL: /* lxvl, lxvll, lxvx */
1557                         opset(ALXVLL, r0)
1558                         opset(ALXVX, r0)
1559
1560                 case ASTXVD2X: /* stxvd2x, stxvdsx, stxvw4x, stxvh8x, stxvb16x */
1561                         opset(ASTXVW4X, r0)
1562                         opset(ASTXVH8X, r0)
1563                         opset(ASTXVB16X, r0)
1564
1565                 case ASTXV: /* stxv */
1566                         opset(ASTXV, r0)
1567
1568                 case ASTXVL: /* stxvl, stxvll, stvx */
1569                         opset(ASTXVLL, r0)
1570                         opset(ASTXVX, r0)
1571
1572                 case ALXSDX: /* lxsdx  */
1573                         opset(ALXSDX, r0)
1574
1575                 case ASTXSDX: /* stxsdx */
1576                         opset(ASTXSDX, r0)
1577
1578                 case ALXSIWAX: /* lxsiwax, lxsiwzx  */
1579                         opset(ALXSIWZX, r0)
1580
1581                 case ASTXSIWX: /* stxsiwx */
1582                         opset(ASTXSIWX, r0)
1583
1584                 case AMFVSRD: /* mfvsrd, mfvsrwz (and extended mnemonics), mfvsrld */
1585                         opset(AMFFPRD, r0)
1586                         opset(AMFVRD, r0)
1587                         opset(AMFVSRWZ, r0)
1588                         opset(AMFVSRLD, r0)
1589
1590                 case AMTVSRD: /* mtvsrd, mtvsrwa, mtvsrwz (and extended mnemonics), mtvsrdd, mtvsrws */
1591                         opset(AMTFPRD, r0)
1592                         opset(AMTVRD, r0)
1593                         opset(AMTVSRWA, r0)
1594                         opset(AMTVSRWZ, r0)
1595                         opset(AMTVSRDD, r0)
1596                         opset(AMTVSRWS, r0)
1597
1598                 case AXXLAND: /* xxland, xxlandc, xxleqv, xxlnand */
1599                         opset(AXXLANDC, r0)
1600                         opset(AXXLEQV, r0)
1601                         opset(AXXLNAND, r0)
1602
1603                 case AXXLOR: /* xxlorc, xxlnor, xxlor, xxlxor */
1604                         opset(AXXLORC, r0)
1605                         opset(AXXLNOR, r0)
1606                         opset(AXXLORQ, r0)
1607                         opset(AXXLXOR, r0)
1608
1609                 case AXXSEL: /* xxsel */
1610                         opset(AXXSEL, r0)
1611
1612                 case AXXMRGHW: /* xxmrghw, xxmrglw */
1613                         opset(AXXMRGLW, r0)
1614
1615                 case AXXSPLTW: /* xxspltw */
1616                         opset(AXXSPLTW, r0)
1617
1618                 case AXXSPLTIB: /* xxspltib */
1619                         opset(AXXSPLTIB, r0)
1620
1621                 case AXXPERM: /* xxpermdi */
1622                         opset(AXXPERM, r0)
1623
1624                 case AXXSLDWI: /* xxsldwi */
1625                         opset(AXXPERMDI, r0)
1626                         opset(AXXSLDWI, r0)
1627
1628                 case AXXBRQ: /* xxbrq, xxbrd, xxbrw, xxbrh */
1629                         opset(AXXBRD, r0)
1630                         opset(AXXBRW, r0)
1631                         opset(AXXBRH, r0)
1632
1633                 case AXSCVDPSP: /* xscvdpsp, xscvspdp, xscvdpspn, xscvspdpn */
1634                         opset(AXSCVSPDP, r0)
1635                         opset(AXSCVDPSPN, r0)
1636                         opset(AXSCVSPDPN, r0)
1637
1638                 case AXVCVDPSP: /* xvcvdpsp, xvcvspdp */
1639                         opset(AXVCVSPDP, r0)
1640
1641                 case AXSCVDPSXDS: /* xscvdpsxds, xscvdpsxws, xscvdpuxds, xscvdpuxws */
1642                         opset(AXSCVDPSXWS, r0)
1643                         opset(AXSCVDPUXDS, r0)
1644                         opset(AXSCVDPUXWS, r0)
1645
1646                 case AXSCVSXDDP: /* xscvsxddp, xscvuxddp, xscvsxdsp, xscvuxdsp */
1647                         opset(AXSCVUXDDP, r0)
1648                         opset(AXSCVSXDSP, r0)
1649                         opset(AXSCVUXDSP, r0)
1650
1651                 case AXVCVDPSXDS: /* xvcvdpsxds, xvcvdpsxws, xvcvdpuxds, xvcvdpuxws, xvcvspsxds, xvcvspsxws, xvcvspuxds, xvcvspuxws */
1652                         opset(AXVCVDPSXDS, r0)
1653                         opset(AXVCVDPSXWS, r0)
1654                         opset(AXVCVDPUXDS, r0)
1655                         opset(AXVCVDPUXWS, r0)
1656                         opset(AXVCVSPSXDS, r0)
1657                         opset(AXVCVSPSXWS, r0)
1658                         opset(AXVCVSPUXDS, r0)
1659                         opset(AXVCVSPUXWS, r0)
1660
1661                 case AXVCVSXDDP: /* xvcvsxddp, xvcvsxwdp, xvcvuxddp, xvcvuxwdp, xvcvsxdsp, xvcvsxwsp, xvcvuxdsp, xvcvuxwsp */
1662                         opset(AXVCVSXWDP, r0)
1663                         opset(AXVCVUXDDP, r0)
1664                         opset(AXVCVUXWDP, r0)
1665                         opset(AXVCVSXDSP, r0)
1666                         opset(AXVCVSXWSP, r0)
1667                         opset(AXVCVUXDSP, r0)
1668                         opset(AXVCVUXWSP, r0)
1669
1670                 case AAND: /* logical op Rb,Rs,Ra; no literal */
1671                         opset(AANDN, r0)
1672                         opset(AANDNCC, r0)
1673                         opset(AEQV, r0)
1674                         opset(AEQVCC, r0)
1675                         opset(ANAND, r0)
1676                         opset(ANANDCC, r0)
1677                         opset(ANOR, r0)
1678                         opset(ANORCC, r0)
1679                         opset(AORCC, r0)
1680                         opset(AORN, r0)
1681                         opset(AORNCC, r0)
1682                         opset(AXORCC, r0)
1683
1684                 case AADDME: /* op Ra, Rd */
1685                         opset(AADDMECC, r0)
1686
1687                         opset(AADDMEV, r0)
1688                         opset(AADDMEVCC, r0)
1689                         opset(AADDZE, r0)
1690                         opset(AADDZECC, r0)
1691                         opset(AADDZEV, r0)
1692                         opset(AADDZEVCC, r0)
1693                         opset(ASUBME, r0)
1694                         opset(ASUBMECC, r0)
1695                         opset(ASUBMEV, r0)
1696                         opset(ASUBMEVCC, r0)
1697                         opset(ASUBZE, r0)
1698                         opset(ASUBZECC, r0)
1699                         opset(ASUBZEV, r0)
1700                         opset(ASUBZEVCC, r0)
1701
1702                 case AADDC:
1703                         opset(AADDCCC, r0)
1704
1705                 case ABEQ:
1706                         opset(ABGE, r0)
1707                         opset(ABGT, r0)
1708                         opset(ABLE, r0)
1709                         opset(ABLT, r0)
1710                         opset(ABNE, r0)
1711                         opset(ABVC, r0)
1712                         opset(ABVS, r0)
1713
1714                 case ABR:
1715                         opset(ABL, r0)
1716
1717                 case ABC:
1718                         opset(ABCL, r0)
1719
1720                 case AEXTSB: /* op Rs, Ra */
1721                         opset(AEXTSBCC, r0)
1722
1723                         opset(AEXTSH, r0)
1724                         opset(AEXTSHCC, r0)
1725                         opset(ACNTLZW, r0)
1726                         opset(ACNTLZWCC, r0)
1727                         opset(ACNTLZD, r0)
1728                         opset(AEXTSW, r0)
1729                         opset(AEXTSWCC, r0)
1730                         opset(ACNTLZDCC, r0)
1731
1732                 case AFABS: /* fop [s,]d */
1733                         opset(AFABSCC, r0)
1734
1735                         opset(AFNABS, r0)
1736                         opset(AFNABSCC, r0)
1737                         opset(AFNEG, r0)
1738                         opset(AFNEGCC, r0)
1739                         opset(AFRSP, r0)
1740                         opset(AFRSPCC, r0)
1741                         opset(AFCTIW, r0)
1742                         opset(AFCTIWCC, r0)
1743                         opset(AFCTIWZ, r0)
1744                         opset(AFCTIWZCC, r0)
1745                         opset(AFCTID, r0)
1746                         opset(AFCTIDCC, r0)
1747                         opset(AFCTIDZ, r0)
1748                         opset(AFCTIDZCC, r0)
1749                         opset(AFCFID, r0)
1750                         opset(AFCFIDCC, r0)
1751                         opset(AFCFIDU, r0)
1752                         opset(AFCFIDUCC, r0)
1753                         opset(AFCFIDS, r0)
1754                         opset(AFCFIDSCC, r0)
1755                         opset(AFRES, r0)
1756                         opset(AFRESCC, r0)
1757                         opset(AFRIM, r0)
1758                         opset(AFRIMCC, r0)
1759                         opset(AFRIP, r0)
1760                         opset(AFRIPCC, r0)
1761                         opset(AFRIZ, r0)
1762                         opset(AFRIZCC, r0)
1763                         opset(AFRIN, r0)
1764                         opset(AFRINCC, r0)
1765                         opset(AFRSQRTE, r0)
1766                         opset(AFRSQRTECC, r0)
1767                         opset(AFSQRT, r0)
1768                         opset(AFSQRTCC, r0)
1769                         opset(AFSQRTS, r0)
1770                         opset(AFSQRTSCC, r0)
1771
1772                 case AFADD:
1773                         opset(AFADDS, r0)
1774                         opset(AFADDCC, r0)
1775                         opset(AFADDSCC, r0)
1776                         opset(AFCPSGN, r0)
1777                         opset(AFCPSGNCC, r0)
1778                         opset(AFDIV, r0)
1779                         opset(AFDIVS, r0)
1780                         opset(AFDIVCC, r0)
1781                         opset(AFDIVSCC, r0)
1782                         opset(AFSUB, r0)
1783                         opset(AFSUBS, r0)
1784                         opset(AFSUBCC, r0)
1785                         opset(AFSUBSCC, r0)
1786
1787                 case AFMADD:
1788                         opset(AFMADDCC, r0)
1789                         opset(AFMADDS, r0)
1790                         opset(AFMADDSCC, r0)
1791                         opset(AFMSUB, r0)
1792                         opset(AFMSUBCC, r0)
1793                         opset(AFMSUBS, r0)
1794                         opset(AFMSUBSCC, r0)
1795                         opset(AFNMADD, r0)
1796                         opset(AFNMADDCC, r0)
1797                         opset(AFNMADDS, r0)
1798                         opset(AFNMADDSCC, r0)
1799                         opset(AFNMSUB, r0)
1800                         opset(AFNMSUBCC, r0)
1801                         opset(AFNMSUBS, r0)
1802                         opset(AFNMSUBSCC, r0)
1803                         opset(AFSEL, r0)
1804                         opset(AFSELCC, r0)
1805
1806                 case AFMUL:
1807                         opset(AFMULS, r0)
1808                         opset(AFMULCC, r0)
1809                         opset(AFMULSCC, r0)
1810
1811                 case AFCMPO:
1812                         opset(AFCMPU, r0)
1813
1814                 case AISEL:
1815                         opset(AISEL, r0)
1816
1817                 case AMTFSB0:
1818                         opset(AMTFSB0CC, r0)
1819                         opset(AMTFSB1, r0)
1820                         opset(AMTFSB1CC, r0)
1821
1822                 case ANEG: /* op [Ra,] Rd */
1823                         opset(ANEGCC, r0)
1824
1825                         opset(ANEGV, r0)
1826                         opset(ANEGVCC, r0)
1827
1828                 case AOR: /* or/xor Rb,Rs,Ra; ori/xori $uimm,Rs,R */
1829                         opset(AXOR, r0)
1830
1831                 case AORIS: /* oris/xoris $uimm,Rs,Ra */
1832                         opset(AXORIS, r0)
1833
1834                 case ASLW:
1835                         opset(ASLWCC, r0)
1836                         opset(ASRW, r0)
1837                         opset(ASRWCC, r0)
1838                         opset(AROTLW, r0)
1839
1840                 case ASLD:
1841                         opset(ASLDCC, r0)
1842                         opset(ASRD, r0)
1843                         opset(ASRDCC, r0)
1844                         opset(AROTL, r0)
1845
1846                 case ASRAW: /* sraw Rb,Rs,Ra; srawi sh,Rs,Ra */
1847                         opset(ASRAWCC, r0)
1848
1849                 case AEXTSWSLI:
1850                         opset(AEXTSWSLICC, r0)
1851
1852                 case ASRAD: /* sraw Rb,Rs,Ra; srawi sh,Rs,Ra */
1853                         opset(ASRADCC, r0)
1854
1855                 case ASUB: /* SUB Ra,Rb,Rd => subf Rd,ra,rb */
1856                         opset(ASUB, r0)
1857
1858                         opset(ASUBCC, r0)
1859                         opset(ASUBV, r0)
1860                         opset(ASUBVCC, r0)
1861                         opset(ASUBCCC, r0)
1862                         opset(ASUBCV, r0)
1863                         opset(ASUBCVCC, r0)
1864                         opset(ASUBE, r0)
1865                         opset(ASUBECC, r0)
1866                         opset(ASUBEV, r0)
1867                         opset(ASUBEVCC, r0)
1868
1869                 case ASYNC:
1870                         opset(AISYNC, r0)
1871                         opset(ALWSYNC, r0)
1872                         opset(APTESYNC, r0)
1873                         opset(ATLBSYNC, r0)
1874
1875                 case ARLWMI:
1876                         opset(ARLWMICC, r0)
1877                         opset(ARLWNM, r0)
1878                         opset(ARLWNMCC, r0)
1879
1880                 case ARLDMI:
1881                         opset(ARLDMICC, r0)
1882                         opset(ARLDIMI, r0)
1883                         opset(ARLDIMICC, r0)
1884
1885                 case ARLDC:
1886                         opset(ARLDCCC, r0)
1887
1888                 case ARLDCL:
1889                         opset(ARLDCR, r0)
1890                         opset(ARLDCLCC, r0)
1891                         opset(ARLDCRCC, r0)
1892
1893                 case ARLDICL:
1894                         opset(ARLDICLCC, r0)
1895                         opset(ARLDICR, r0)
1896                         opset(ARLDICRCC, r0)
1897                         opset(ARLDIC, r0)
1898                         opset(ARLDICCC, r0)
1899                         opset(ACLRLSLDI, r0)
1900
1901                 case AFMOVD:
1902                         opset(AFMOVDCC, r0)
1903                         opset(AFMOVDU, r0)
1904                         opset(AFMOVS, r0)
1905                         opset(AFMOVSU, r0)
1906
1907                 case ALDAR:
1908                         opset(ALBAR, r0)
1909                         opset(ALHAR, r0)
1910                         opset(ALWAR, r0)
1911
1912                 case ASYSCALL: /* just the op; flow of control */
1913                         opset(ARFI, r0)
1914
1915                         opset(ARFCI, r0)
1916                         opset(ARFID, r0)
1917                         opset(AHRFID, r0)
1918
1919                 case AMOVHBR:
1920                         opset(AMOVWBR, r0)
1921                         opset(AMOVDBR, r0)
1922
1923                 case ASLBMFEE:
1924                         opset(ASLBMFEV, r0)
1925
1926                 case ATW:
1927                         opset(ATD, r0)
1928
1929                 case ATLBIE:
1930                         opset(ASLBIE, r0)
1931                         opset(ATLBIEL, r0)
1932
1933                 case AEIEIO:
1934                         opset(ASLBIA, r0)
1935
1936                 case ACMP:
1937                         opset(ACMPW, r0)
1938
1939                 case ACMPU:
1940                         opset(ACMPWU, r0)
1941
1942                 case ACMPB:
1943                         opset(ACMPB, r0)
1944
1945                 case AFTDIV:
1946                         opset(AFTDIV, r0)
1947
1948                 case AFTSQRT:
1949                         opset(AFTSQRT, r0)
1950
1951                 case AADD,
1952                         AADDIS,
1953                         AANDCC, /* and. Rb,Rs,Ra; andi. $uimm,Rs,Ra */
1954                         AANDISCC,
1955                         AFMOVSX,
1956                         AFMOVSZ,
1957                         ALSW,
1958                         AMOVW,
1959                         /* load/store/move word with sign extension; special 32-bit move; move 32-bit literals */
1960                         AMOVWZ, /* load/store/move word with zero extension; move 32-bit literals  */
1961                         AMOVD,  /* load/store/move 64-bit values, including 32-bit literals with/without sign-extension */
1962                         AMOVB,  /* macro: move byte with sign extension */
1963                         AMOVBU, /* macro: move byte with sign extension & update */
1964                         AMOVFL,
1965                         /* op $s[,r2],r3; op r1[,r2],r3; no cc/v */
1966                         ASUBC, /* op r1,$s,r3; op r1[,r2],r3 */
1967                         ASTSW,
1968                         ASLBMTE,
1969                         AWORD,
1970                         ADWORD,
1971                         ADARN,
1972                         ALDMX,
1973                         AVMSUMUDM,
1974                         AADDEX,
1975                         ACMPEQB,
1976                         AECIWX,
1977                         ACLRLSLWI,
1978                         obj.ANOP,
1979                         obj.ATEXT,
1980                         obj.AUNDEF,
1981                         obj.AFUNCDATA,
1982                         obj.APCALIGN,
1983                         obj.APCDATA,
1984                         obj.ADUFFZERO,
1985                         obj.ADUFFCOPY:
1986                         break
1987                 }
1988         }
1989 }
1990
1991 func OPVXX1(o uint32, xo uint32, oe uint32) uint32 {
1992         return o<<26 | xo<<1 | oe<<11
1993 }
1994
1995 func OPVXX2(o uint32, xo uint32, oe uint32) uint32 {
1996         return o<<26 | xo<<2 | oe<<11
1997 }
1998
1999 func OPVXX2VA(o uint32, xo uint32, oe uint32) uint32 {
2000         return o<<26 | xo<<2 | oe<<16
2001 }
2002
2003 func OPVXX3(o uint32, xo uint32, oe uint32) uint32 {
2004         return o<<26 | xo<<3 | oe<<11
2005 }
2006
2007 func OPVXX4(o uint32, xo uint32, oe uint32) uint32 {
2008         return o<<26 | xo<<4 | oe<<11
2009 }
2010
2011 func OPDQ(o uint32, xo uint32, oe uint32) uint32 {
2012         return o<<26 | xo | oe<<4
2013 }
2014
2015 func OPVX(o uint32, xo uint32, oe uint32, rc uint32) uint32 {
2016         return o<<26 | xo | oe<<11 | rc&1
2017 }
2018
2019 func OPVC(o uint32, xo uint32, oe uint32, rc uint32) uint32 {
2020         return o<<26 | xo | oe<<11 | (rc&1)<<10
2021 }
2022
2023 func OPVCC(o uint32, xo uint32, oe uint32, rc uint32) uint32 {
2024         return o<<26 | xo<<1 | oe<<10 | rc&1
2025 }
2026
2027 func OPCC(o uint32, xo uint32, rc uint32) uint32 {
2028         return OPVCC(o, xo, 0, rc)
2029 }
2030
2031 /* the order is dest, a/s, b/imm for both arithmetic and logical operations */
2032 func AOP_RRR(op uint32, d uint32, a uint32, b uint32) uint32 {
2033         return op | (d&31)<<21 | (a&31)<<16 | (b&31)<<11
2034 }
2035
2036 /* VX-form 2-register operands, r/none/r */
2037 func AOP_RR(op uint32, d uint32, a uint32) uint32 {
2038         return op | (d&31)<<21 | (a&31)<<11
2039 }
2040
2041 /* VA-form 4-register operands */
2042 func AOP_RRRR(op uint32, d uint32, a uint32, b uint32, c uint32) uint32 {
2043         return op | (d&31)<<21 | (a&31)<<16 | (b&31)<<11 | (c&31)<<6
2044 }
2045
2046 func AOP_IRR(op uint32, d uint32, a uint32, simm uint32) uint32 {
2047         return op | (d&31)<<21 | (a&31)<<16 | simm&0xFFFF
2048 }
2049
2050 /* VX-form 2-register + UIM operands */
2051 func AOP_VIRR(op uint32, d uint32, a uint32, simm uint32) uint32 {
2052         return op | (d&31)<<21 | (simm&0xFFFF)<<16 | (a&31)<<11
2053 }
2054
2055 /* VX-form 2-register + ST + SIX operands */
2056 func AOP_IIRR(op uint32, d uint32, a uint32, sbit uint32, simm uint32) uint32 {
2057         return op | (d&31)<<21 | (a&31)<<16 | (sbit&1)<<15 | (simm&0xF)<<11
2058 }
2059
2060 /* VA-form 3-register + SHB operands */
2061 func AOP_IRRR(op uint32, d uint32, a uint32, b uint32, simm uint32) uint32 {
2062         return op | (d&31)<<21 | (a&31)<<16 | (b&31)<<11 | (simm&0xF)<<6
2063 }
2064
2065 /* VX-form 1-register + SIM operands */
2066 func AOP_IR(op uint32, d uint32, simm uint32) uint32 {
2067         return op | (d&31)<<21 | (simm&31)<<16
2068 }
2069
2070 /* XX1-form 3-register operands, 1 VSR operand */
2071 func AOP_XX1(op uint32, d uint32, a uint32, b uint32) uint32 {
2072         /* For the XX-form encodings, we need the VSX register number to be exactly */
2073         /* between 0-63, so we can properly set the rightmost bits. */
2074         r := d - REG_VS0
2075         return op | (r&31)<<21 | (a&31)<<16 | (b&31)<<11 | (r&32)>>5
2076 }
2077
2078 /* XX2-form 3-register operands, 2 VSR operands */
2079 func AOP_XX2(op uint32, d uint32, a uint32, b uint32) uint32 {
2080         xt := d - REG_VS0
2081         xb := b - REG_VS0
2082         return op | (xt&31)<<21 | (a&3)<<16 | (xb&31)<<11 | (xb&32)>>4 | (xt&32)>>5
2083 }
2084
2085 /* XX3-form 3 VSR operands */
2086 func AOP_XX3(op uint32, d uint32, a uint32, b uint32) uint32 {
2087         xt := d - REG_VS0
2088         xa := a - REG_VS0
2089         xb := b - REG_VS0
2090         return op | (xt&31)<<21 | (xa&31)<<16 | (xb&31)<<11 | (xa&32)>>3 | (xb&32)>>4 | (xt&32)>>5
2091 }
2092
2093 /* XX3-form 3 VSR operands + immediate */
2094 func AOP_XX3I(op uint32, d uint32, a uint32, b uint32, c uint32) uint32 {
2095         xt := d - REG_VS0
2096         xa := a - REG_VS0
2097         xb := b - REG_VS0
2098         return op | (xt&31)<<21 | (xa&31)<<16 | (xb&31)<<11 | (c&3)<<8 | (xa&32)>>3 | (xb&32)>>4 | (xt&32)>>5
2099 }
2100
2101 /* XX4-form, 4 VSR operands */
2102 func AOP_XX4(op uint32, d uint32, a uint32, b uint32, c uint32) uint32 {
2103         xt := d - REG_VS0
2104         xa := a - REG_VS0
2105         xb := b - REG_VS0
2106         xc := c - REG_VS0
2107         return op | (xt&31)<<21 | (xa&31)<<16 | (xb&31)<<11 | (xc&31)<<6 | (xc&32)>>2 | (xa&32)>>3 | (xb&32)>>4 | (xt&32)>>5
2108 }
2109
2110 /* DQ-form, VSR register, register + offset operands */
2111 func AOP_DQ(op uint32, d uint32, a uint32, b uint32) uint32 {
2112         /* For the DQ-form encodings, we need the VSX register number to be exactly */
2113         /* between 0-63, so we can properly set the SX bit. */
2114         r := d - REG_VS0
2115         /* The EA for this instruction form is (RA) + DQ << 4, where DQ is a 12-bit signed integer. */
2116         /* In order to match the output of the GNU objdump (and make the usage in Go asm easier), the */
2117         /* instruction is called using the sign extended value (i.e. a valid offset would be -32752 or 32752, */
2118         /* not -2047 or 2047), so 'b' needs to be adjusted to the expected 12-bit DQ value. Bear in mind that */
2119         /* bits 0 to 3 in 'dq' need to be zero, otherwise this will generate an illegal instruction. */
2120         /* If in doubt how this instruction form is encoded, refer to ISA 3.0b, pages 492 and 507. */
2121         dq := b >> 4
2122         return op | (r&31)<<21 | (a&31)<<16 | (dq&4095)<<4 | (r&32)>>2
2123 }
2124
2125 /* Z23-form, 3-register operands + CY field */
2126 func AOP_Z23I(op uint32, d uint32, a uint32, b uint32, c uint32) uint32 {
2127         return op | (d&31)<<21 | (a&31)<<16 | (b&31)<<11 | (c&3)<<9
2128 }
2129
2130 /* X-form, 3-register operands + EH field */
2131 func AOP_RRRI(op uint32, d uint32, a uint32, b uint32, c uint32) uint32 {
2132         return op | (d&31)<<21 | (a&31)<<16 | (b&31)<<11 | (c & 1)
2133 }
2134
2135 func LOP_RRR(op uint32, a uint32, s uint32, b uint32) uint32 {
2136         return op | (s&31)<<21 | (a&31)<<16 | (b&31)<<11
2137 }
2138
2139 func LOP_IRR(op uint32, a uint32, s uint32, uimm uint32) uint32 {
2140         return op | (s&31)<<21 | (a&31)<<16 | uimm&0xFFFF
2141 }
2142
2143 func OP_BR(op uint32, li uint32, aa uint32) uint32 {
2144         return op | li&0x03FFFFFC | aa<<1
2145 }
2146
2147 func OP_BC(op uint32, bo uint32, bi uint32, bd uint32, aa uint32) uint32 {
2148         return op | (bo&0x1F)<<21 | (bi&0x1F)<<16 | bd&0xFFFC | aa<<1
2149 }
2150
2151 func OP_BCR(op uint32, bo uint32, bi uint32) uint32 {
2152         return op | (bo&0x1F)<<21 | (bi&0x1F)<<16
2153 }
2154
2155 func OP_RLW(op uint32, a uint32, s uint32, sh uint32, mb uint32, me uint32) uint32 {
2156         return op | (s&31)<<21 | (a&31)<<16 | (sh&31)<<11 | (mb&31)<<6 | (me&31)<<1
2157 }
2158
2159 func AOP_RLDIC(op uint32, a uint32, s uint32, sh uint32, m uint32) uint32 {
2160         return op | (s&31)<<21 | (a&31)<<16 | (sh&31)<<11 | ((sh&32)>>5)<<1 | (m&31)<<6 | ((m&32)>>5)<<5
2161 }
2162
2163 func AOP_EXTSWSLI(op uint32, a uint32, s uint32, sh uint32) uint32 {
2164         return op | (a&31)<<21 | (s&31)<<16 | (sh&31)<<11 | ((sh&32)>>5)<<1
2165 }
2166
2167 func AOP_ISEL(op uint32, t uint32, a uint32, b uint32, bc uint32) uint32 {
2168         return op | (t&31)<<21 | (a&31)<<16 | (b&31)<<11 | (bc&0x1F)<<6
2169 }
2170
2171 const (
2172         /* each rhs is OPVCC(_, _, _, _) */
2173         OP_ADD      = 31<<26 | 266<<1 | 0<<10 | 0
2174         OP_ADDI     = 14<<26 | 0<<1 | 0<<10 | 0
2175         OP_ADDIS    = 15<<26 | 0<<1 | 0<<10 | 0
2176         OP_ANDI     = 28<<26 | 0<<1 | 0<<10 | 0
2177         OP_EXTSB    = 31<<26 | 954<<1 | 0<<10 | 0
2178         OP_EXTSH    = 31<<26 | 922<<1 | 0<<10 | 0
2179         OP_EXTSW    = 31<<26 | 986<<1 | 0<<10 | 0
2180         OP_ISEL     = 31<<26 | 15<<1 | 0<<10 | 0
2181         OP_MCRF     = 19<<26 | 0<<1 | 0<<10 | 0
2182         OP_MCRFS    = 63<<26 | 64<<1 | 0<<10 | 0
2183         OP_MCRXR    = 31<<26 | 512<<1 | 0<<10 | 0
2184         OP_MFCR     = 31<<26 | 19<<1 | 0<<10 | 0
2185         OP_MFFS     = 63<<26 | 583<<1 | 0<<10 | 0
2186         OP_MFMSR    = 31<<26 | 83<<1 | 0<<10 | 0
2187         OP_MFSPR    = 31<<26 | 339<<1 | 0<<10 | 0
2188         OP_MFSR     = 31<<26 | 595<<1 | 0<<10 | 0
2189         OP_MFSRIN   = 31<<26 | 659<<1 | 0<<10 | 0
2190         OP_MTCRF    = 31<<26 | 144<<1 | 0<<10 | 0
2191         OP_MTFSF    = 63<<26 | 711<<1 | 0<<10 | 0
2192         OP_MTFSFI   = 63<<26 | 134<<1 | 0<<10 | 0
2193         OP_MTMSR    = 31<<26 | 146<<1 | 0<<10 | 0
2194         OP_MTMSRD   = 31<<26 | 178<<1 | 0<<10 | 0
2195         OP_MTSPR    = 31<<26 | 467<<1 | 0<<10 | 0
2196         OP_MTSR     = 31<<26 | 210<<1 | 0<<10 | 0
2197         OP_MTSRIN   = 31<<26 | 242<<1 | 0<<10 | 0
2198         OP_MULLW    = 31<<26 | 235<<1 | 0<<10 | 0
2199         OP_MULLD    = 31<<26 | 233<<1 | 0<<10 | 0
2200         OP_OR       = 31<<26 | 444<<1 | 0<<10 | 0
2201         OP_ORI      = 24<<26 | 0<<1 | 0<<10 | 0
2202         OP_ORIS     = 25<<26 | 0<<1 | 0<<10 | 0
2203         OP_RLWINM   = 21<<26 | 0<<1 | 0<<10 | 0
2204         OP_RLWNM    = 23<<26 | 0<<1 | 0<<10 | 0
2205         OP_SUBF     = 31<<26 | 40<<1 | 0<<10 | 0
2206         OP_RLDIC    = 30<<26 | 4<<1 | 0<<10 | 0
2207         OP_RLDICR   = 30<<26 | 2<<1 | 0<<10 | 0
2208         OP_RLDICL   = 30<<26 | 0<<1 | 0<<10 | 0
2209         OP_RLDCL    = 30<<26 | 8<<1 | 0<<10 | 0
2210         OP_EXTSWSLI = 31<<26 | 445<<2
2211 )
2212
2213 func oclass(a *obj.Addr) int {
2214         return int(a.Class) - 1
2215 }
2216
2217 const (
2218         D_FORM = iota
2219         DS_FORM
2220 )
2221
2222 // This function determines when a non-indexed load or store is D or
2223 // DS form for use in finding the size of the offset field in the instruction.
2224 // The size is needed when setting the offset value in the instruction
2225 // and when generating relocation for that field.
2226 // DS form instructions include: ld, ldu, lwa, std, stdu.  All other
2227 // loads and stores with an offset field are D form.  This function should
2228 // only be called with the same opcodes as are handled by opstore and opload.
2229 func (c *ctxt9) opform(insn uint32) int {
2230         switch insn {
2231         default:
2232                 c.ctxt.Diag("bad insn in loadform: %x", insn)
2233         case OPVCC(58, 0, 0, 0), // ld
2234                 OPVCC(58, 0, 0, 1),        // ldu
2235                 OPVCC(58, 0, 0, 0) | 1<<1, // lwa
2236                 OPVCC(62, 0, 0, 0),        // std
2237                 OPVCC(62, 0, 0, 1):        //stdu
2238                 return DS_FORM
2239         case OP_ADDI, // add
2240                 OPVCC(32, 0, 0, 0), // lwz
2241                 OPVCC(33, 0, 0, 0), // lwzu
2242                 OPVCC(34, 0, 0, 0), // lbz
2243                 OPVCC(35, 0, 0, 0), // lbzu
2244                 OPVCC(40, 0, 0, 0), // lhz
2245                 OPVCC(41, 0, 0, 0), // lhzu
2246                 OPVCC(42, 0, 0, 0), // lha
2247                 OPVCC(43, 0, 0, 0), // lhau
2248                 OPVCC(46, 0, 0, 0), // lmw
2249                 OPVCC(48, 0, 0, 0), // lfs
2250                 OPVCC(49, 0, 0, 0), // lfsu
2251                 OPVCC(50, 0, 0, 0), // lfd
2252                 OPVCC(51, 0, 0, 0), // lfdu
2253                 OPVCC(36, 0, 0, 0), // stw
2254                 OPVCC(37, 0, 0, 0), // stwu
2255                 OPVCC(38, 0, 0, 0), // stb
2256                 OPVCC(39, 0, 0, 0), // stbu
2257                 OPVCC(44, 0, 0, 0), // sth
2258                 OPVCC(45, 0, 0, 0), // sthu
2259                 OPVCC(47, 0, 0, 0), // stmw
2260                 OPVCC(52, 0, 0, 0), // stfs
2261                 OPVCC(53, 0, 0, 0), // stfsu
2262                 OPVCC(54, 0, 0, 0), // stfd
2263                 OPVCC(55, 0, 0, 0): // stfdu
2264                 return D_FORM
2265         }
2266         return 0
2267 }
2268
2269 // Encode instructions and create relocation for accessing s+d according to the
2270 // instruction op with source or destination (as appropriate) register reg.
2271 func (c *ctxt9) symbolAccess(s *obj.LSym, d int64, reg int16, op uint32) (o1, o2 uint32) {
2272         if c.ctxt.Headtype == objabi.Haix {
2273                 // Every symbol access must be made via a TOC anchor.
2274                 c.ctxt.Diag("symbolAccess called for %s", s.Name)
2275         }
2276         var base uint32
2277         form := c.opform(op)
2278         if c.ctxt.Flag_shared {
2279                 base = REG_R2
2280         } else {
2281                 base = REG_R0
2282         }
2283         o1 = AOP_IRR(OP_ADDIS, REGTMP, base, 0)
2284         o2 = AOP_IRR(op, uint32(reg), REGTMP, 0)
2285         rel := obj.Addrel(c.cursym)
2286         rel.Off = int32(c.pc)
2287         rel.Siz = 8
2288         rel.Sym = s
2289         rel.Add = d
2290         if c.ctxt.Flag_shared {
2291                 switch form {
2292                 case D_FORM:
2293                         rel.Type = objabi.R_ADDRPOWER_TOCREL
2294                 case DS_FORM:
2295                         rel.Type = objabi.R_ADDRPOWER_TOCREL_DS
2296                 }
2297
2298         } else {
2299                 switch form {
2300                 case D_FORM:
2301                         rel.Type = objabi.R_ADDRPOWER
2302                 case DS_FORM:
2303                         rel.Type = objabi.R_ADDRPOWER_DS
2304                 }
2305         }
2306         return
2307 }
2308
2309 /*
2310  * 32-bit masks
2311  */
2312 func getmask(m []byte, v uint32) bool {
2313         m[1] = 0
2314         m[0] = m[1]
2315         if v != ^uint32(0) && v&(1<<31) != 0 && v&1 != 0 { /* MB > ME */
2316                 if getmask(m, ^v) {
2317                         i := int(m[0])
2318                         m[0] = m[1] + 1
2319                         m[1] = byte(i - 1)
2320                         return true
2321                 }
2322
2323                 return false
2324         }
2325
2326         for i := 0; i < 32; i++ {
2327                 if v&(1<<uint(31-i)) != 0 {
2328                         m[0] = byte(i)
2329                         for {
2330                                 m[1] = byte(i)
2331                                 i++
2332                                 if i >= 32 || v&(1<<uint(31-i)) == 0 {
2333                                         break
2334                                 }
2335                         }
2336
2337                         for ; i < 32; i++ {
2338                                 if v&(1<<uint(31-i)) != 0 {
2339                                         return false
2340                                 }
2341                         }
2342                         return true
2343                 }
2344         }
2345
2346         return false
2347 }
2348
2349 func (c *ctxt9) maskgen(p *obj.Prog, m []byte, v uint32) {
2350         if !getmask(m, v) {
2351                 c.ctxt.Diag("cannot generate mask #%x\n%v", v, p)
2352         }
2353 }
2354
2355 /*
2356  * 64-bit masks (rldic etc)
2357  */
2358 func getmask64(m []byte, v uint64) bool {
2359         m[1] = 0
2360         m[0] = m[1]
2361         for i := 0; i < 64; i++ {
2362                 if v&(uint64(1)<<uint(63-i)) != 0 {
2363                         m[0] = byte(i)
2364                         for {
2365                                 m[1] = byte(i)
2366                                 i++
2367                                 if i >= 64 || v&(uint64(1)<<uint(63-i)) == 0 {
2368                                         break
2369                                 }
2370                         }
2371
2372                         for ; i < 64; i++ {
2373                                 if v&(uint64(1)<<uint(63-i)) != 0 {
2374                                         return false
2375                                 }
2376                         }
2377                         return true
2378                 }
2379         }
2380
2381         return false
2382 }
2383
2384 func (c *ctxt9) maskgen64(p *obj.Prog, m []byte, v uint64) {
2385         if !getmask64(m, v) {
2386                 c.ctxt.Diag("cannot generate mask #%x\n%v", v, p)
2387         }
2388 }
2389
2390 func loadu32(r int, d int64) uint32 {
2391         v := int32(d >> 16)
2392         if isuint32(uint64(d)) {
2393                 return LOP_IRR(OP_ORIS, uint32(r), REGZERO, uint32(v))
2394         }
2395         return AOP_IRR(OP_ADDIS, uint32(r), REGZERO, uint32(v))
2396 }
2397
2398 func high16adjusted(d int32) uint16 {
2399         if d&0x8000 != 0 {
2400                 return uint16((d >> 16) + 1)
2401         }
2402         return uint16(d >> 16)
2403 }
2404
2405 func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
2406         o1 := uint32(0)
2407         o2 := uint32(0)
2408         o3 := uint32(0)
2409         o4 := uint32(0)
2410         o5 := uint32(0)
2411
2412         //print("%v => case %d\n", p, o->type);
2413         switch o.type_ {
2414         default:
2415                 c.ctxt.Diag("unknown type %d", o.type_)
2416                 prasm(p)
2417
2418         case 0: /* pseudo ops */
2419                 break
2420
2421         case 1: /* mov r1,r2 ==> OR Rs,Rs,Ra */
2422                 if p.To.Reg == REGZERO && p.From.Type == obj.TYPE_CONST {
2423                         v := c.regoff(&p.From)
2424                         if r0iszero != 0 /*TypeKind(100016)*/ && v != 0 {
2425                                 //nerrors--;
2426                                 c.ctxt.Diag("literal operation on R0\n%v", p)
2427                         }
2428
2429                         o1 = LOP_IRR(OP_ADDI, REGZERO, REGZERO, uint32(v))
2430                         break
2431                 }
2432
2433                 o1 = LOP_RRR(OP_OR, uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.From.Reg))
2434
2435         case 2: /* int/cr/fp op Rb,[Ra],Rd */
2436                 r := int(p.Reg)
2437
2438                 if r == 0 {
2439                         r = int(p.To.Reg)
2440                 }
2441                 o1 = AOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), uint32(r), uint32(p.From.Reg))
2442
2443         case 3: /* mov $soreg/addcon/andcon/ucon, r ==> addis/oris/addi/ori $i,reg',r */
2444                 d := c.vregoff(&p.From)
2445
2446                 v := int32(d)
2447                 r := int(p.From.Reg)
2448                 if r == 0 {
2449                         r = c.getimpliedreg(&p.From, p)
2450                 }
2451                 if r0iszero != 0 /*TypeKind(100016)*/ && p.To.Reg == 0 && (r != 0 || v != 0) {
2452                         c.ctxt.Diag("literal operation on R0\n%v", p)
2453                 }
2454                 a := OP_ADDI
2455                 if o.a1 == C_UCON {
2456                         if d&0xffff != 0 {
2457                                 log.Fatalf("invalid handling of %v", p)
2458                         }
2459                         // For UCON operands the value is right shifted 16, using ADDIS if the
2460                         // value should be signed, ORIS if unsigned.
2461                         v >>= 16
2462                         if r == REGZERO && isuint32(uint64(d)) {
2463                                 o1 = LOP_IRR(OP_ORIS, uint32(p.To.Reg), REGZERO, uint32(v))
2464                                 break
2465                         }
2466
2467                         a = OP_ADDIS
2468                 } else if int64(int16(d)) != d {
2469                         // Operand is 16 bit value with sign bit set
2470                         if o.a1 == C_ANDCON {
2471                                 // Needs unsigned 16 bit so use ORI
2472                                 if r == 0 || r == REGZERO {
2473                                         o1 = LOP_IRR(uint32(OP_ORI), uint32(p.To.Reg), uint32(0), uint32(v))
2474                                         break
2475                                 }
2476                                 // With ADDCON, needs signed 16 bit value, fall through to use ADDI
2477                         } else if o.a1 != C_ADDCON {
2478                                 log.Fatalf("invalid handling of %v", p)
2479                         }
2480                 }
2481
2482                 o1 = AOP_IRR(uint32(a), uint32(p.To.Reg), uint32(r), uint32(v))
2483
2484         case 4: /* add/mul $scon,[r1],r2 */
2485                 v := c.regoff(&p.From)
2486
2487                 r := int(p.Reg)
2488                 if r == 0 {
2489                         r = int(p.To.Reg)
2490                 }
2491                 if r0iszero != 0 /*TypeKind(100016)*/ && p.To.Reg == 0 {
2492                         c.ctxt.Diag("literal operation on R0\n%v", p)
2493                 }
2494                 if int32(int16(v)) != v {
2495                         log.Fatalf("mishandled instruction %v", p)
2496                 }
2497                 o1 = AOP_IRR(c.opirr(p.As), uint32(p.To.Reg), uint32(r), uint32(v))
2498
2499         case 5: /* syscall */
2500                 o1 = c.oprrr(p.As)
2501
2502         case 6: /* logical op Rb,[Rs,]Ra; no literal */
2503                 r := int(p.Reg)
2504
2505                 if r == 0 {
2506                         r = int(p.To.Reg)
2507                 }
2508                 // AROTL and AROTLW are extended mnemonics, which map to RLDCL and RLWNM.
2509                 switch p.As {
2510                 case AROTL:
2511                         o1 = AOP_RLDIC(OP_RLDCL, uint32(p.To.Reg), uint32(r), uint32(p.From.Reg), uint32(0))
2512                 case AROTLW:
2513                         o1 = OP_RLW(OP_RLWNM, uint32(p.To.Reg), uint32(r), uint32(p.From.Reg), 0, 31)
2514                 default:
2515                         o1 = LOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), uint32(r), uint32(p.From.Reg))
2516                 }
2517
2518         case 7: /* mov r, soreg ==> stw o(r) */
2519                 r := int(p.To.Reg)
2520
2521                 if r == 0 {
2522                         r = c.getimpliedreg(&p.To, p)
2523                 }
2524                 v := c.regoff(&p.To)
2525                 if p.To.Type == obj.TYPE_MEM && p.To.Index != 0 {
2526                         if v != 0 {
2527                                 c.ctxt.Diag("illegal indexed instruction\n%v", p)
2528                         }
2529                         if c.ctxt.Flag_shared && r == REG_R13 {
2530                                 rel := obj.Addrel(c.cursym)
2531                                 rel.Off = int32(c.pc)
2532                                 rel.Siz = 4
2533                                 // This (and the matching part in the load case
2534                                 // below) are the only places in the ppc64 toolchain
2535                                 // that knows the name of the tls variable. Possibly
2536                                 // we could add some assembly syntax so that the name
2537                                 // of the variable does not have to be assumed.
2538                                 rel.Sym = c.ctxt.Lookup("runtime.tls_g")
2539                                 rel.Type = objabi.R_POWER_TLS
2540                         }
2541                         o1 = AOP_RRR(c.opstorex(p.As), uint32(p.From.Reg), uint32(p.To.Index), uint32(r))
2542                 } else {
2543                         if int32(int16(v)) != v {
2544                                 log.Fatalf("mishandled instruction %v", p)
2545                         }
2546                         // Offsets in DS form stores must be a multiple of 4
2547                         inst := c.opstore(p.As)
2548                         if c.opform(inst) == DS_FORM && v&0x3 != 0 {
2549                                 log.Fatalf("invalid offset for DS form load/store %v", p)
2550                         }
2551                         o1 = AOP_IRR(inst, uint32(p.From.Reg), uint32(r), uint32(v))
2552                 }
2553
2554         case 8: /* mov soreg, r ==> lbz/lhz/lwz o(r) */
2555                 r := int(p.From.Reg)
2556
2557                 if r == 0 {
2558                         r = c.getimpliedreg(&p.From, p)
2559                 }
2560                 v := c.regoff(&p.From)
2561                 if p.From.Type == obj.TYPE_MEM && p.From.Index != 0 {
2562                         if v != 0 {
2563                                 c.ctxt.Diag("illegal indexed instruction\n%v", p)
2564                         }
2565                         if c.ctxt.Flag_shared && r == REG_R13 {
2566                                 rel := obj.Addrel(c.cursym)
2567                                 rel.Off = int32(c.pc)
2568                                 rel.Siz = 4
2569                                 rel.Sym = c.ctxt.Lookup("runtime.tls_g")
2570                                 rel.Type = objabi.R_POWER_TLS
2571                         }
2572                         o1 = AOP_RRR(c.oploadx(p.As), uint32(p.To.Reg), uint32(p.From.Index), uint32(r))
2573                 } else {
2574                         if int32(int16(v)) != v {
2575                                 log.Fatalf("mishandled instruction %v", p)
2576                         }
2577                         // Offsets in DS form loads must be a multiple of 4
2578                         inst := c.opload(p.As)
2579                         if c.opform(inst) == DS_FORM && v&0x3 != 0 {
2580                                 log.Fatalf("invalid offset for DS form load/store %v", p)
2581                         }
2582                         o1 = AOP_IRR(inst, uint32(p.To.Reg), uint32(r), uint32(v))
2583                 }
2584
2585         case 9: /* movb soreg, r ==> lbz o(r),r2; extsb r2,r2 */
2586                 r := int(p.From.Reg)
2587
2588                 if r == 0 {
2589                         r = c.getimpliedreg(&p.From, p)
2590                 }
2591                 v := c.regoff(&p.From)
2592                 if p.From.Type == obj.TYPE_MEM && p.From.Index != 0 {
2593                         if v != 0 {
2594                                 c.ctxt.Diag("illegal indexed instruction\n%v", p)
2595                         }
2596                         o1 = AOP_RRR(c.oploadx(p.As), uint32(p.To.Reg), uint32(p.From.Index), uint32(r))
2597                 } else {
2598                         o1 = AOP_IRR(c.opload(p.As), uint32(p.To.Reg), uint32(r), uint32(v))
2599                 }
2600                 o2 = LOP_RRR(OP_EXTSB, uint32(p.To.Reg), uint32(p.To.Reg), 0)
2601
2602         case 10: /* sub Ra,[Rb],Rd => subf Rd,Ra,Rb */
2603                 r := int(p.Reg)
2604
2605                 if r == 0 {
2606                         r = int(p.To.Reg)
2607                 }
2608                 o1 = AOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), uint32(p.From.Reg), uint32(r))
2609
2610         case 11: /* br/bl lbra */
2611                 v := int32(0)
2612
2613                 if p.To.Target() != nil {
2614                         v = int32(p.To.Target().Pc - p.Pc)
2615                         if v&03 != 0 {
2616                                 c.ctxt.Diag("odd branch target address\n%v", p)
2617                                 v &^= 03
2618                         }
2619
2620                         if v < -(1<<25) || v >= 1<<24 {
2621                                 c.ctxt.Diag("branch too far\n%v", p)
2622                         }
2623                 }
2624
2625                 o1 = OP_BR(c.opirr(p.As), uint32(v), 0)
2626                 if p.To.Sym != nil {
2627                         rel := obj.Addrel(c.cursym)
2628                         rel.Off = int32(c.pc)
2629                         rel.Siz = 4
2630                         rel.Sym = p.To.Sym
2631                         v += int32(p.To.Offset)
2632                         if v&03 != 0 {
2633                                 c.ctxt.Diag("odd branch target address\n%v", p)
2634                                 v &^= 03
2635                         }
2636
2637                         rel.Add = int64(v)
2638                         rel.Type = objabi.R_CALLPOWER
2639                 }
2640                 o2 = 0x60000000 // nop, sometimes overwritten by ld r2, 24(r1) when dynamic linking
2641
2642         case 12: /* movb r,r (extsb); movw r,r (extsw) */
2643                 if p.To.Reg == REGZERO && p.From.Type == obj.TYPE_CONST {
2644                         v := c.regoff(&p.From)
2645                         if r0iszero != 0 /*TypeKind(100016)*/ && v != 0 {
2646                                 c.ctxt.Diag("literal operation on R0\n%v", p)
2647                         }
2648
2649                         o1 = LOP_IRR(OP_ADDI, REGZERO, REGZERO, uint32(v))
2650                         break
2651                 }
2652
2653                 if p.As == AMOVW {
2654                         o1 = LOP_RRR(OP_EXTSW, uint32(p.To.Reg), uint32(p.From.Reg), 0)
2655                 } else {
2656                         o1 = LOP_RRR(OP_EXTSB, uint32(p.To.Reg), uint32(p.From.Reg), 0)
2657                 }
2658
2659         case 13: /* mov[bhw]z r,r; uses rlwinm not andi. to avoid changing CC */
2660                 if p.As == AMOVBZ {
2661                         o1 = OP_RLW(OP_RLWINM, uint32(p.To.Reg), uint32(p.From.Reg), 0, 24, 31)
2662                 } else if p.As == AMOVH {
2663                         o1 = LOP_RRR(OP_EXTSH, uint32(p.To.Reg), uint32(p.From.Reg), 0)
2664                 } else if p.As == AMOVHZ {
2665                         o1 = OP_RLW(OP_RLWINM, uint32(p.To.Reg), uint32(p.From.Reg), 0, 16, 31)
2666                 } else if p.As == AMOVWZ {
2667                         o1 = OP_RLW(OP_RLDIC, uint32(p.To.Reg), uint32(p.From.Reg), 0, 0, 0) | 1<<5 /* MB=32 */
2668                 } else {
2669                         c.ctxt.Diag("internal: bad mov[bhw]z\n%v", p)
2670                 }
2671
2672         case 14: /* rldc[lr] Rb,Rs,$mask,Ra -- left, right give different masks */
2673                 r := int(p.Reg)
2674
2675                 if r == 0 {
2676                         r = int(p.To.Reg)
2677                 }
2678                 d := c.vregoff(p.GetFrom3())
2679                 var a int
2680                 switch p.As {
2681
2682                 // These opcodes expect a mask operand that has to be converted into the
2683                 // appropriate operand.  The way these were defined, not all valid masks are possible.
2684                 // Left here for compatibility in case they were used or generated.
2685                 case ARLDCL, ARLDCLCC:
2686                         var mask [2]uint8
2687                         c.maskgen64(p, mask[:], uint64(d))
2688
2689                         a = int(mask[0]) /* MB */
2690                         if mask[1] != 63 {
2691                                 c.ctxt.Diag("invalid mask for rotate: %x (end != bit 63)\n%v", uint64(d), p)
2692                         }
2693                         o1 = LOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), uint32(r), uint32(p.From.Reg))
2694                         o1 |= (uint32(a) & 31) << 6
2695                         if a&0x20 != 0 {
2696                                 o1 |= 1 << 5 /* mb[5] is top bit */
2697                         }
2698
2699                 case ARLDCR, ARLDCRCC:
2700                         var mask [2]uint8
2701                         c.maskgen64(p, mask[:], uint64(d))
2702
2703                         a = int(mask[1]) /* ME */
2704                         if mask[0] != 0 {
2705                                 c.ctxt.Diag("invalid mask for rotate: %x %x (start != 0)\n%v", uint64(d), mask[0], p)
2706                         }
2707                         o1 = LOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), uint32(r), uint32(p.From.Reg))
2708                         o1 |= (uint32(a) & 31) << 6
2709                         if a&0x20 != 0 {
2710                                 o1 |= 1 << 5 /* mb[5] is top bit */
2711                         }
2712
2713                 // These opcodes use a shift count like the ppc64 asm, no mask conversion done
2714                 case ARLDICR, ARLDICRCC:
2715                         me := int(d)
2716                         sh := c.regoff(&p.From)
2717                         if me < 0 || me > 63 || sh > 63 {
2718                                 c.ctxt.Diag("Invalid me or sh for RLDICR: %x %x\n%v", int(d), sh, p)
2719                         }
2720                         o1 = AOP_RLDIC(c.oprrr(p.As), uint32(p.To.Reg), uint32(r), uint32(sh), uint32(me))
2721
2722                 case ARLDICL, ARLDICLCC, ARLDIC, ARLDICCC:
2723                         mb := int(d)
2724                         sh := c.regoff(&p.From)
2725                         if mb < 0 || mb > 63 || sh > 63 {
2726                                 c.ctxt.Diag("Invalid mb or sh for RLDIC, RLDICL: %x %x\n%v", mb, sh, p)
2727                         }
2728                         o1 = AOP_RLDIC(c.oprrr(p.As), uint32(p.To.Reg), uint32(r), uint32(sh), uint32(mb))
2729
2730                 case ACLRLSLDI:
2731                         // This is an extended mnemonic defined in the ISA section C.8.1
2732                         // clrlsldi ra,rs,b,n --> rldic ra,rs,n,b-n
2733                         // It maps onto RLDIC so is directly generated here based on the operands from
2734                         // the clrlsldi.
2735                         n := int32(d)
2736                         b := c.regoff(&p.From)
2737                         if n > b || b > 63 {
2738                                 c.ctxt.Diag("Invalid n or b for CLRLSLDI: %x %x\n%v", n, b, p)
2739                         }
2740                         o1 = AOP_RLDIC(OP_RLDIC, uint32(p.To.Reg), uint32(r), uint32(n), uint32(b)-uint32(n))
2741
2742                 default:
2743                         c.ctxt.Diag("unexpected op in rldc case\n%v", p)
2744                         a = 0
2745                 }
2746
2747         case 17, /* bc bo,bi,lbra (same for now) */
2748                 16: /* bc bo,bi,sbra */
2749                 a := 0
2750
2751                 r := int(p.Reg)
2752
2753                 if p.From.Type == obj.TYPE_CONST {
2754                         a = int(c.regoff(&p.From))
2755                 } else if p.From.Type == obj.TYPE_REG {
2756                         if r != 0 {
2757                                 c.ctxt.Diag("unexpected register setting for branch with CR: %d\n", r)
2758                         }
2759                         // BI values for the CR
2760                         switch p.From.Reg {
2761                         case REG_CR0:
2762                                 r = BI_CR0
2763                         case REG_CR1:
2764                                 r = BI_CR1
2765                         case REG_CR2:
2766                                 r = BI_CR2
2767                         case REG_CR3:
2768                                 r = BI_CR3
2769                         case REG_CR4:
2770                                 r = BI_CR4
2771                         case REG_CR5:
2772                                 r = BI_CR5
2773                         case REG_CR6:
2774                                 r = BI_CR6
2775                         case REG_CR7:
2776                                 r = BI_CR7
2777                         default:
2778                                 c.ctxt.Diag("unrecognized register: expecting CR\n")
2779                         }
2780                 }
2781                 v := int32(0)
2782                 if p.To.Target() != nil {
2783                         v = int32(p.To.Target().Pc - p.Pc)
2784                 }
2785                 if v&03 != 0 {
2786                         c.ctxt.Diag("odd branch target address\n%v", p)
2787                         v &^= 03
2788                 }
2789
2790                 if v < -(1<<16) || v >= 1<<15 {
2791                         c.ctxt.Diag("branch too far\n%v", p)
2792                 }
2793                 o1 = OP_BC(c.opirr(p.As), uint32(a), uint32(r), uint32(v), 0)
2794
2795         case 15: /* br/bl (r) => mov r,lr; br/bl (lr) */
2796                 var v int32
2797                 if p.As == ABC || p.As == ABCL {
2798                         v = c.regoff(&p.To) & 31
2799                 } else {
2800                         v = 20 /* unconditional */
2801                 }
2802                 o1 = AOP_RRR(OP_MTSPR, uint32(p.To.Reg), 0, 0) | (REG_LR&0x1f)<<16 | ((REG_LR>>5)&0x1f)<<11
2803                 o2 = OPVCC(19, 16, 0, 0)
2804                 if p.As == ABL || p.As == ABCL {
2805                         o2 |= 1
2806                 }
2807                 o2 = OP_BCR(o2, uint32(v), uint32(p.To.Index))
2808
2809         case 18: /* br/bl (lr/ctr); bc/bcl bo,bi,(lr/ctr) */
2810                 var v int32
2811                 var bh uint32 = 0
2812                 if p.As == ABC || p.As == ABCL {
2813                         v = c.regoff(&p.From) & 31
2814                 } else {
2815                         v = 20 /* unconditional */
2816                 }
2817                 r := int(p.Reg)
2818                 if r == 0 {
2819                         r = 0
2820                 }
2821                 switch oclass(&p.To) {
2822                 case C_CTR:
2823                         o1 = OPVCC(19, 528, 0, 0)
2824
2825                 case C_LR:
2826                         o1 = OPVCC(19, 16, 0, 0)
2827
2828                 default:
2829                         c.ctxt.Diag("bad optab entry (18): %d\n%v", p.To.Class, p)
2830                         v = 0
2831                 }
2832
2833                 // Insert optional branch hint for bclr[l]/bcctr[l]
2834                 if p.From3Type() != obj.TYPE_NONE {
2835                         bh = uint32(p.GetFrom3().Offset)
2836                         if bh == 2 || bh > 3 {
2837                                 log.Fatalf("BH must be 0,1,3 for %v", p)
2838                         }
2839                         o1 |= bh << 11
2840                 }
2841
2842                 if p.As == ABL || p.As == ABCL {
2843                         o1 |= 1
2844                 }
2845                 o1 = OP_BCR(o1, uint32(v), uint32(r))
2846
2847         case 19: /* mov $lcon,r ==> cau+or */
2848                 d := c.vregoff(&p.From)
2849
2850                 if p.From.Sym == nil {
2851                         o1 = loadu32(int(p.To.Reg), d)
2852                         o2 = LOP_IRR(OP_ORI, uint32(p.To.Reg), uint32(p.To.Reg), uint32(int32(d)))
2853                 } else {
2854                         o1, o2 = c.symbolAccess(p.From.Sym, d, p.To.Reg, OP_ADDI)
2855                 }
2856
2857         case 20: /* add $ucon,,r | addis $addcon,r,r */
2858                 v := c.regoff(&p.From)
2859
2860                 r := int(p.Reg)
2861                 if r == 0 {
2862                         r = int(p.To.Reg)
2863                 }
2864                 if p.As == AADD && (r0iszero == 0 /*TypeKind(100016)*/ && p.Reg == 0 || r0iszero != 0 /*TypeKind(100016)*/ && p.To.Reg == 0) {
2865                         c.ctxt.Diag("literal operation on R0\n%v", p)
2866                 }
2867                 if p.As == AADDIS {
2868                         o1 = AOP_IRR(c.opirr(p.As), uint32(p.To.Reg), uint32(r), uint32(v))
2869                 } else {
2870                         o1 = AOP_IRR(c.opirr(AADDIS), uint32(p.To.Reg), uint32(r), uint32(v)>>16)
2871                 }
2872
2873         case 22: /* add $lcon/$andcon,r1,r2 ==> oris+ori+add/ori+add */
2874                 if p.To.Reg == REGTMP || p.Reg == REGTMP {
2875                         c.ctxt.Diag("can't synthesize large constant\n%v", p)
2876                 }
2877                 d := c.vregoff(&p.From)
2878                 r := int(p.Reg)
2879                 if r == 0 {
2880                         r = int(p.To.Reg)
2881                 }
2882                 if p.From.Sym != nil {
2883                         c.ctxt.Diag("%v is not supported", p)
2884                 }
2885                 // If operand is ANDCON, generate 2 instructions using
2886                 // ORI for unsigned value; with LCON 3 instructions.
2887                 if o.size == 8 {
2888                         o1 = LOP_IRR(OP_ORI, REGTMP, REGZERO, uint32(int32(d)))
2889                         o2 = AOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), REGTMP, uint32(r))
2890                 } else {
2891                         o1 = loadu32(REGTMP, d)
2892                         o2 = LOP_IRR(OP_ORI, REGTMP, REGTMP, uint32(int32(d)))
2893                         o3 = AOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), REGTMP, uint32(r))
2894                 }
2895
2896         case 23: /* and $lcon/$addcon,r1,r2 ==> oris+ori+and/addi+and */
2897                 if p.To.Reg == REGTMP || p.Reg == REGTMP {
2898                         c.ctxt.Diag("can't synthesize large constant\n%v", p)
2899                 }
2900                 d := c.vregoff(&p.From)
2901                 r := int(p.Reg)
2902                 if r == 0 {
2903                         r = int(p.To.Reg)
2904                 }
2905
2906                 // With ADDCON operand, generate 2 instructions using ADDI for signed value,
2907                 // with LCON operand generate 3 instructions.
2908                 if o.size == 8 {
2909                         o1 = LOP_IRR(OP_ADDI, REGZERO, REGTMP, uint32(int32(d)))
2910                         o2 = LOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), REGTMP, uint32(r))
2911                 } else {
2912                         o1 = loadu32(REGTMP, d)
2913                         o2 = LOP_IRR(OP_ORI, REGTMP, REGTMP, uint32(int32(d)))
2914                         o3 = LOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), REGTMP, uint32(r))
2915                 }
2916                 if p.From.Sym != nil {
2917                         c.ctxt.Diag("%v is not supported", p)
2918                 }
2919
2920         case 24: /* lfd fA,float64(0) -> xxlxor xsA,xsaA,xsaA + fneg for -0 */
2921                 o1 = AOP_XX3I(c.oprrr(AXXLXOR), uint32(p.To.Reg), uint32(p.To.Reg), uint32(p.To.Reg), uint32(0))
2922                 // This is needed for -0.
2923                 if o.size == 8 {
2924                         o2 = AOP_RRR(c.oprrr(AFNEG), uint32(p.To.Reg), 0, uint32(p.To.Reg))
2925                 }
2926
2927         case 25:
2928                 /* sld[.] $sh,rS,rA -> rldicr[.] $sh,rS,mask(0,63-sh),rA; srd[.] -> rldicl */
2929                 v := c.regoff(&p.From)
2930
2931                 if v < 0 {
2932                         v = 0
2933                 } else if v > 63 {
2934                         v = 63
2935                 }
2936                 r := int(p.Reg)
2937                 if r == 0 {
2938                         r = int(p.To.Reg)
2939                 }
2940                 var a int
2941                 op := uint32(0)
2942                 switch p.As {
2943                 case ASLD, ASLDCC:
2944                         a = int(63 - v)
2945                         op = OP_RLDICR
2946
2947                 case ASRD, ASRDCC:
2948                         a = int(v)
2949                         v = 64 - v
2950                         op = OP_RLDICL
2951                 case AROTL:
2952                         a = int(0)
2953                         op = OP_RLDICL
2954                 case AEXTSWSLI:
2955                         a = int(v)
2956                 default:
2957                         c.ctxt.Diag("unexpected op in sldi case\n%v", p)
2958                         a = 0
2959                         o1 = 0
2960                 }
2961
2962                 if p.As == AEXTSWSLI || p.As == AEXTSWSLICC {
2963                         o1 = AOP_EXTSWSLI(OP_EXTSWSLI, uint32(r), uint32(p.To.Reg), uint32(v))
2964
2965                 } else {
2966                         o1 = AOP_RLDIC(op, uint32(p.To.Reg), uint32(r), uint32(v), uint32(a))
2967                 }
2968                 if p.As == ASLDCC || p.As == ASRDCC || p.As == AEXTSWSLICC {
2969                         o1 |= 1 // Set the condition code bit
2970                 }
2971
2972         case 26: /* mov $lsext/auto/oreg,,r2 ==> addis+addi */
2973                 if p.To.Reg == REGTMP {
2974                         c.ctxt.Diag("can't synthesize large constant\n%v", p)
2975                 }
2976                 v := c.regoff(&p.From)
2977                 r := int(p.From.Reg)
2978                 if r == 0 {
2979                         r = c.getimpliedreg(&p.From, p)
2980                 }
2981                 o1 = AOP_IRR(OP_ADDIS, REGTMP, uint32(r), uint32(high16adjusted(v)))
2982                 o2 = AOP_IRR(OP_ADDI, uint32(p.To.Reg), REGTMP, uint32(v))
2983
2984         case 27: /* subc ra,$simm,rd => subfic rd,ra,$simm */
2985                 v := c.regoff(p.GetFrom3())
2986
2987                 r := int(p.From.Reg)
2988                 o1 = AOP_IRR(c.opirr(p.As), uint32(p.To.Reg), uint32(r), uint32(v))
2989
2990         case 28: /* subc r1,$lcon,r2 ==> cau+or+subfc */
2991                 if p.To.Reg == REGTMP || p.From.Reg == REGTMP {
2992                         c.ctxt.Diag("can't synthesize large constant\n%v", p)
2993                 }
2994                 v := c.regoff(p.GetFrom3())
2995                 o1 = AOP_IRR(OP_ADDIS, REGTMP, REGZERO, uint32(v)>>16)
2996                 o2 = LOP_IRR(OP_ORI, REGTMP, REGTMP, uint32(v))
2997                 o3 = AOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), uint32(p.From.Reg), REGTMP)
2998                 if p.From.Sym != nil {
2999                         c.ctxt.Diag("%v is not supported", p)
3000                 }
3001
3002         case 29: /* rldic[lr]? $sh,s,$mask,a -- left, right, plain give different masks */
3003                 v := c.regoff(&p.From)
3004
3005                 d := c.vregoff(p.GetFrom3())
3006                 var mask [2]uint8
3007                 c.maskgen64(p, mask[:], uint64(d))
3008                 var a int
3009                 switch p.As {
3010                 case ARLDC, ARLDCCC:
3011                         a = int(mask[0]) /* MB */
3012                         if int32(mask[1]) != (63 - v) {
3013                                 c.ctxt.Diag("invalid mask for shift: %x %x (shift %d)\n%v", uint64(d), mask[1], v, p)
3014                         }
3015
3016                 case ARLDCL, ARLDCLCC:
3017                         a = int(mask[0]) /* MB */
3018                         if mask[1] != 63 {
3019                                 c.ctxt.Diag("invalid mask for shift: %x %s (shift %d)\n%v", uint64(d), mask[1], v, p)
3020                         }
3021
3022                 case ARLDCR, ARLDCRCC:
3023                         a = int(mask[1]) /* ME */
3024                         if mask[0] != 0 {
3025                                 c.ctxt.Diag("invalid mask for shift: %x %x (shift %d)\n%v", uint64(d), mask[0], v, p)
3026                         }
3027
3028                 default:
3029                         c.ctxt.Diag("unexpected op in rldic case\n%v", p)
3030                         a = 0
3031                 }
3032
3033                 o1 = AOP_RRR(c.opirr(p.As), uint32(p.Reg), uint32(p.To.Reg), (uint32(v) & 0x1F))
3034                 o1 |= (uint32(a) & 31) << 6
3035                 if v&0x20 != 0 {
3036                         o1 |= 1 << 1
3037                 }
3038                 if a&0x20 != 0 {
3039                         o1 |= 1 << 5 /* mb[5] is top bit */
3040                 }
3041
3042         case 30: /* rldimi $sh,s,$mask,a */
3043                 v := c.regoff(&p.From)
3044
3045                 d := c.vregoff(p.GetFrom3())
3046
3047                 // Original opcodes had mask operands which had to be converted to a shift count as expected by
3048                 // the ppc64 asm.
3049                 switch p.As {
3050                 case ARLDMI, ARLDMICC:
3051                         var mask [2]uint8
3052                         c.maskgen64(p, mask[:], uint64(d))
3053                         if int32(mask[1]) != (63 - v) {
3054                                 c.ctxt.Diag("invalid mask for shift: %x %x (shift %d)\n%v", uint64(d), mask[1], v, p)
3055                         }
3056                         o1 = AOP_RRR(c.opirr(p.As), uint32(p.Reg), uint32(p.To.Reg), (uint32(v) & 0x1F))
3057                         o1 |= (uint32(mask[0]) & 31) << 6
3058                         if v&0x20 != 0 {
3059                                 o1 |= 1 << 1
3060                         }
3061                         if mask[0]&0x20 != 0 {
3062                                 o1 |= 1 << 5 /* mb[5] is top bit */
3063                         }
3064
3065                 // Opcodes with shift count operands.
3066                 case ARLDIMI, ARLDIMICC:
3067                         o1 = AOP_RRR(c.opirr(p.As), uint32(p.Reg), uint32(p.To.Reg), (uint32(v) & 0x1F))
3068                         o1 |= (uint32(d) & 31) << 6
3069                         if d&0x20 != 0 {
3070                                 o1 |= 1 << 5
3071                         }
3072                         if v&0x20 != 0 {
3073                                 o1 |= 1 << 1
3074                         }
3075                 }
3076
3077         case 31: /* dword */
3078                 d := c.vregoff(&p.From)
3079
3080                 if c.ctxt.Arch.ByteOrder == binary.BigEndian {
3081                         o1 = uint32(d >> 32)
3082                         o2 = uint32(d)
3083                 } else {
3084                         o1 = uint32(d)
3085                         o2 = uint32(d >> 32)
3086                 }
3087
3088                 if p.From.Sym != nil {
3089                         rel := obj.Addrel(c.cursym)
3090                         rel.Off = int32(c.pc)
3091                         rel.Siz = 8
3092                         rel.Sym = p.From.Sym
3093                         rel.Add = p.From.Offset
3094                         rel.Type = objabi.R_ADDR
3095                         o2 = 0
3096                         o1 = o2
3097                 }
3098
3099         case 32: /* fmul frc,fra,frd */
3100                 r := int(p.Reg)
3101
3102                 if r == 0 {
3103                         r = int(p.To.Reg)
3104                 }
3105                 o1 = AOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), uint32(r), 0) | (uint32(p.From.Reg)&31)<<6
3106
3107         case 33: /* fabs [frb,]frd; fmr. frb,frd */
3108                 r := int(p.From.Reg)
3109
3110                 if oclass(&p.From) == C_NONE {
3111                         r = int(p.To.Reg)
3112                 }
3113                 o1 = AOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), 0, uint32(r))
3114
3115         case 34: /* FMADDx fra,frb,frc,frt (t=a*c±b) */
3116                 o1 = AOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.Reg)) | (uint32(p.GetFrom3().Reg)&31)<<6
3117
3118         case 35: /* mov r,lext/lauto/loreg ==> cau $(v>>16),sb,r'; store o(r') */
3119                 v := c.regoff(&p.To)
3120
3121                 r := int(p.To.Reg)
3122                 if r == 0 {
3123                         r = c.getimpliedreg(&p.To, p)
3124                 }
3125                 // Offsets in DS form stores must be a multiple of 4
3126                 inst := c.opstore(p.As)
3127                 if c.opform(inst) == DS_FORM && v&0x3 != 0 {
3128                         log.Fatalf("invalid offset for DS form load/store %v", p)
3129                 }
3130                 o1 = AOP_IRR(OP_ADDIS, REGTMP, uint32(r), uint32(high16adjusted(v)))
3131                 o2 = AOP_IRR(inst, uint32(p.From.Reg), REGTMP, uint32(v))
3132
3133         case 36: /* mov bz/h/hz lext/lauto/lreg,r ==> lbz/lha/lhz etc */
3134                 v := c.regoff(&p.From)
3135
3136                 r := int(p.From.Reg)
3137                 if r == 0 {
3138                         r = c.getimpliedreg(&p.From, p)
3139                 }
3140                 o1 = AOP_IRR(OP_ADDIS, REGTMP, uint32(r), uint32(high16adjusted(v)))
3141                 o2 = AOP_IRR(c.opload(p.As), uint32(p.To.Reg), REGTMP, uint32(v))
3142
3143         case 37: /* movb lext/lauto/lreg,r ==> lbz o(reg),r; extsb r */
3144                 v := c.regoff(&p.From)
3145
3146                 r := int(p.From.Reg)
3147                 if r == 0 {
3148                         r = c.getimpliedreg(&p.From, p)
3149                 }
3150                 o1 = AOP_IRR(OP_ADDIS, REGTMP, uint32(r), uint32(high16adjusted(v)))
3151                 o2 = AOP_IRR(c.opload(p.As), uint32(p.To.Reg), REGTMP, uint32(v))
3152                 o3 = LOP_RRR(OP_EXTSB, uint32(p.To.Reg), uint32(p.To.Reg), 0)
3153
3154         case 40: /* word */
3155                 o1 = uint32(c.regoff(&p.From))
3156
3157         case 41: /* stswi */
3158                 o1 = AOP_RRR(c.opirr(p.As), uint32(p.From.Reg), uint32(p.To.Reg), 0) | (uint32(c.regoff(p.GetFrom3()))&0x7F)<<11
3159
3160         case 42: /* lswi */
3161                 o1 = AOP_RRR(c.opirr(p.As), uint32(p.To.Reg), uint32(p.From.Reg), 0) | (uint32(c.regoff(p.GetFrom3()))&0x7F)<<11
3162
3163         case 43: /* data cache instructions: op (Ra+[Rb]), [th|l] */
3164                 /* TH field for dcbt/dcbtst: */
3165                 /* 0 = Block access - program will soon access EA. */
3166                 /* 8-15 = Stream access - sequence of access (data stream). See section 4.3.2 of the ISA for details. */
3167                 /* 16 = Block access - program will soon make a transient access to EA. */
3168                 /* 17 = Block access - program will not access EA for a long time. */
3169
3170                 /* L field for dcbf: */
3171                 /* 0 = invalidates the block containing EA in all processors. */
3172                 /* 1 = same as 0, but with limited scope (i.e. block in the current processor will not be reused soon). */
3173                 /* 3 = same as 1, but with even more limited scope (i.e. block in the current processor primary cache will not be reused soon). */
3174                 if p.To.Type == obj.TYPE_NONE {
3175                         o1 = AOP_RRR(c.oprrr(p.As), 0, uint32(p.From.Index), uint32(p.From.Reg))
3176                 } else {
3177                         th := c.regoff(&p.To)
3178                         o1 = AOP_RRR(c.oprrr(p.As), uint32(th), uint32(p.From.Index), uint32(p.From.Reg))
3179                 }
3180
3181         case 44: /* indexed store */
3182                 o1 = AOP_RRR(c.opstorex(p.As), uint32(p.From.Reg), uint32(p.To.Index), uint32(p.To.Reg))
3183
3184         case 45: /* indexed load */
3185                 switch p.As {
3186                 /* The assembler accepts a 4-operand l*arx instruction. The fourth operand is an Exclusive Access Hint (EH) */
3187                 /* The EH field can be used as a lock acquire/release hint as follows: */
3188                 /* 0 = Atomic Update (fetch-and-operate or similar algorithm) */
3189                 /* 1 = Exclusive Access (lock acquire and release) */
3190                 case ALBAR, ALHAR, ALWAR, ALDAR:
3191                         if p.From3Type() != obj.TYPE_NONE {
3192                                 eh := int(c.regoff(p.GetFrom3()))
3193                                 if eh > 1 {
3194                                         c.ctxt.Diag("illegal EH field\n%v", p)
3195                                 }
3196                                 o1 = AOP_RRRI(c.oploadx(p.As), uint32(p.To.Reg), uint32(p.From.Index), uint32(p.From.Reg), uint32(eh))
3197                         } else {
3198                                 o1 = AOP_RRR(c.oploadx(p.As), uint32(p.To.Reg), uint32(p.From.Index), uint32(p.From.Reg))
3199                         }
3200                 default:
3201                         o1 = AOP_RRR(c.oploadx(p.As), uint32(p.To.Reg), uint32(p.From.Index), uint32(p.From.Reg))
3202                 }
3203         case 46: /* plain op */
3204                 o1 = c.oprrr(p.As)
3205
3206         case 47: /* op Ra, Rd; also op [Ra,] Rd */
3207                 r := int(p.From.Reg)
3208
3209                 if r == 0 {
3210                         r = int(p.To.Reg)
3211                 }
3212                 o1 = AOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), uint32(r), 0)
3213
3214         case 48: /* op Rs, Ra */
3215                 r := int(p.From.Reg)
3216
3217                 if r == 0 {
3218                         r = int(p.To.Reg)
3219                 }
3220                 o1 = LOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), uint32(r), 0)
3221
3222         case 49: /* op Rb; op $n, Rb */
3223                 if p.From.Type != obj.TYPE_REG { /* tlbie $L, rB */
3224                         v := c.regoff(&p.From) & 1
3225                         o1 = AOP_RRR(c.oprrr(p.As), 0, 0, uint32(p.To.Reg)) | uint32(v)<<21
3226                 } else {
3227                         o1 = AOP_RRR(c.oprrr(p.As), 0, 0, uint32(p.From.Reg))
3228                 }
3229
3230         case 50: /* rem[u] r1[,r2],r3 */
3231                 r := int(p.Reg)
3232
3233                 if r == 0 {
3234                         r = int(p.To.Reg)
3235                 }
3236                 v := c.oprrr(p.As)
3237                 t := v & (1<<10 | 1) /* OE|Rc */
3238                 o1 = AOP_RRR(v&^t, REGTMP, uint32(r), uint32(p.From.Reg))
3239                 o2 = AOP_RRR(OP_MULLW, REGTMP, REGTMP, uint32(p.From.Reg))
3240                 o3 = AOP_RRR(OP_SUBF|t, uint32(p.To.Reg), REGTMP, uint32(r))
3241                 if p.As == AREMU {
3242                         o4 = o3
3243
3244                         /* Clear top 32 bits */
3245                         o3 = OP_RLW(OP_RLDIC, REGTMP, REGTMP, 0, 0, 0) | 1<<5
3246                 }
3247
3248         case 51: /* remd[u] r1[,r2],r3 */
3249                 r := int(p.Reg)
3250
3251                 if r == 0 {
3252                         r = int(p.To.Reg)
3253                 }
3254                 v := c.oprrr(p.As)
3255                 t := v & (1<<10 | 1) /* OE|Rc */
3256                 o1 = AOP_RRR(v&^t, REGTMP, uint32(r), uint32(p.From.Reg))
3257                 o2 = AOP_RRR(OP_MULLD, REGTMP, REGTMP, uint32(p.From.Reg))
3258                 o3 = AOP_RRR(OP_SUBF|t, uint32(p.To.Reg), REGTMP, uint32(r))
3259                 /* cases 50,51: removed; can be reused. */
3260
3261                 /* cases 50,51: removed; can be reused. */
3262
3263         case 52: /* mtfsbNx cr(n) */
3264                 v := c.regoff(&p.From) & 31
3265
3266                 o1 = AOP_RRR(c.oprrr(p.As), uint32(v), 0, 0)
3267
3268         case 53: /* mffsX ,fr1 */
3269                 o1 = AOP_RRR(OP_MFFS, uint32(p.To.Reg), 0, 0)
3270
3271         case 54: /* mov msr,r1; mov r1, msr*/
3272                 if oclass(&p.From) == C_REG {
3273                         if p.As == AMOVD {
3274                                 o1 = AOP_RRR(OP_MTMSRD, uint32(p.From.Reg), 0, 0)
3275                         } else {
3276                                 o1 = AOP_RRR(OP_MTMSR, uint32(p.From.Reg), 0, 0)
3277                         }
3278                 } else {
3279                         o1 = AOP_RRR(OP_MFMSR, uint32(p.To.Reg), 0, 0)
3280                 }
3281
3282         case 55: /* op Rb, Rd */
3283                 o1 = AOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), 0, uint32(p.From.Reg))
3284
3285         case 56: /* sra $sh,[s,]a; srd $sh,[s,]a */
3286                 v := c.regoff(&p.From)
3287
3288                 r := int(p.Reg)
3289                 if r == 0 {
3290                         r = int(p.To.Reg)
3291                 }
3292                 o1 = AOP_RRR(c.opirr(p.As), uint32(r), uint32(p.To.Reg), uint32(v)&31)
3293                 if (p.As == ASRAD || p.As == ASRADCC) && (v&0x20 != 0) {
3294                         o1 |= 1 << 1 /* mb[5] */
3295                 }
3296
3297         case 57: /* slw $sh,[s,]a -> rlwinm ... */
3298                 v := c.regoff(&p.From)
3299
3300                 r := int(p.Reg)
3301                 if r == 0 {
3302                         r = int(p.To.Reg)
3303                 }
3304
3305                 /*
3306                          * Let user (gs) shoot himself in the foot.
3307                          * qc has already complained.
3308                          *
3309                         if(v < 0 || v > 31)
3310                                 ctxt->diag("illegal shift %ld\n%v", v, p);
3311                 */
3312                 if v < 0 {
3313                         v = 0
3314                 } else if v > 32 {
3315                         v = 32
3316                 }
3317                 var mask [2]uint8
3318                 switch p.As {
3319                 case AROTLW:
3320                         mask[0], mask[1] = 0, 31
3321                 case ASRW, ASRWCC:
3322                         mask[0], mask[1] = uint8(v), 31
3323                         v = 32 - v
3324                 default:
3325                         mask[0], mask[1] = 0, uint8(31-v)
3326                 }
3327                 o1 = OP_RLW(OP_RLWINM, uint32(p.To.Reg), uint32(r), uint32(v), uint32(mask[0]), uint32(mask[1]))
3328                 if p.As == ASLWCC || p.As == ASRWCC {
3329                         o1 |= 1 // set the condition code
3330                 }
3331
3332         case 58: /* logical $andcon,[s],a */
3333                 v := c.regoff(&p.From)
3334
3335                 r := int(p.Reg)
3336                 if r == 0 {
3337                         r = int(p.To.Reg)
3338                 }
3339                 o1 = LOP_IRR(c.opirr(p.As), uint32(p.To.Reg), uint32(r), uint32(v))
3340
3341         case 59: /* or/xor/and $ucon,,r | oris/xoris/andis $addcon,r,r */
3342                 v := c.regoff(&p.From)
3343
3344                 r := int(p.Reg)
3345                 if r == 0 {
3346                         r = int(p.To.Reg)
3347                 }
3348                 switch p.As {
3349                 case AOR:
3350                         o1 = LOP_IRR(c.opirr(AORIS), uint32(p.To.Reg), uint32(r), uint32(v)>>16) /* oris, xoris, andis. */
3351                 case AXOR:
3352                         o1 = LOP_IRR(c.opirr(AXORIS), uint32(p.To.Reg), uint32(r), uint32(v)>>16)
3353                 case AANDCC:
3354                         o1 = LOP_IRR(c.opirr(AANDISCC), uint32(p.To.Reg), uint32(r), uint32(v)>>16)
3355                 default:
3356                         o1 = LOP_IRR(c.opirr(p.As), uint32(p.To.Reg), uint32(r), uint32(v))
3357                 }
3358
3359         case 60: /* tw to,a,b */
3360                 r := int(c.regoff(&p.From) & 31)
3361
3362                 o1 = AOP_RRR(c.oprrr(p.As), uint32(r), uint32(p.Reg), uint32(p.To.Reg))
3363
3364         case 61: /* tw to,a,$simm */
3365                 r := int(c.regoff(&p.From) & 31)
3366
3367                 v := c.regoff(&p.To)
3368                 o1 = AOP_IRR(c.opirr(p.As), uint32(r), uint32(p.Reg), uint32(v))
3369
3370         case 62: /* rlwmi $sh,s,$mask,a */
3371                 v := c.regoff(&p.From)
3372                 switch p.As {
3373                 case ACLRLSLWI:
3374                         n := c.regoff(p.GetFrom3())
3375                         // This is an extended mnemonic described in the ISA C.8.2
3376                         // clrlslwi ra,rs,b,n -> rlwinm ra,rs,n,b-n,31-n
3377                         // It maps onto rlwinm which is directly generated here.
3378                         if n > v || v >= 32 {
3379                                 c.ctxt.Diag("Invalid n or b for CLRLSLWI: %x %x\n%v", v, n, p)
3380                         }
3381
3382                         o1 = OP_RLW(OP_RLWINM, uint32(p.To.Reg), uint32(p.Reg), uint32(n), uint32(v-n), uint32(31-n))
3383                 default:
3384                         var mask [2]uint8
3385                         c.maskgen(p, mask[:], uint32(c.regoff(p.GetFrom3())))
3386                         o1 = AOP_RRR(c.opirr(p.As), uint32(p.Reg), uint32(p.To.Reg), uint32(v))
3387                         o1 |= (uint32(mask[0])&31)<<6 | (uint32(mask[1])&31)<<1
3388                 }
3389
3390         case 63: /* rlwmi b,s,$mask,a */
3391                 var mask [2]uint8
3392                 c.maskgen(p, mask[:], uint32(c.regoff(p.GetFrom3())))
3393                 o1 = AOP_RRR(c.oprrr(p.As), uint32(p.Reg), uint32(p.To.Reg), uint32(p.From.Reg))
3394                 o1 |= (uint32(mask[0])&31)<<6 | (uint32(mask[1])&31)<<1
3395
3396         case 64: /* mtfsf fr[, $m] {,fpcsr} */
3397                 var v int32
3398                 if p.From3Type() != obj.TYPE_NONE {
3399                         v = c.regoff(p.GetFrom3()) & 255
3400                 } else {
3401                         v = 255
3402                 }
3403                 o1 = OP_MTFSF | uint32(v)<<17 | uint32(p.From.Reg)<<11
3404
3405         case 65: /* MOVFL $imm,FPSCR(n) => mtfsfi crfd,imm */
3406                 if p.To.Reg == 0 {
3407                         c.ctxt.Diag("must specify FPSCR(n)\n%v", p)
3408                 }
3409                 o1 = OP_MTFSFI | (uint32(p.To.Reg)&15)<<23 | (uint32(c.regoff(&p.From))&31)<<12
3410
3411         case 66: /* mov spr,r1; mov r1,spr, also dcr */
3412                 var r int
3413                 var v int32
3414                 if REG_R0 <= p.From.Reg && p.From.Reg <= REG_R31 {
3415                         r = int(p.From.Reg)
3416                         v = int32(p.To.Reg)
3417                         if REG_DCR0 <= v && v <= REG_DCR0+1023 {
3418                                 o1 = OPVCC(31, 451, 0, 0) /* mtdcr */
3419                         } else {
3420                                 o1 = OPVCC(31, 467, 0, 0) /* mtspr */
3421                         }
3422                 } else {
3423                         r = int(p.To.Reg)
3424                         v = int32(p.From.Reg)
3425                         if REG_DCR0 <= v && v <= REG_DCR0+1023 {
3426                                 o1 = OPVCC(31, 323, 0, 0) /* mfdcr */
3427                         } else {
3428                                 o1 = OPVCC(31, 339, 0, 0) /* mfspr */
3429                         }
3430                 }
3431
3432                 o1 = AOP_RRR(o1, uint32(r), 0, 0) | (uint32(v)&0x1f)<<16 | ((uint32(v)>>5)&0x1f)<<11
3433
3434         case 67: /* mcrf crfD,crfS */
3435                 if p.From.Type != obj.TYPE_REG || p.From.Reg < REG_CR0 || REG_CR7 < p.From.Reg || p.To.Type != obj.TYPE_REG || p.To.Reg < REG_CR0 || REG_CR7 < p.To.Reg {
3436                         c.ctxt.Diag("illegal CR field number\n%v", p)
3437                 }
3438                 o1 = AOP_RRR(OP_MCRF, ((uint32(p.To.Reg) & 7) << 2), ((uint32(p.From.Reg) & 7) << 2), 0)
3439
3440         case 68: /* mfcr rD; mfocrf CRM,rD */
3441                 if p.From.Type == obj.TYPE_REG && REG_CR0 <= p.From.Reg && p.From.Reg <= REG_CR7 {
3442                         v := int32(1 << uint(7-(p.To.Reg&7)))                                 /* CR(n) */
3443                         o1 = AOP_RRR(OP_MFCR, uint32(p.To.Reg), 0, 0) | 1<<20 | uint32(v)<<12 /* new form, mfocrf */
3444                 } else {
3445                         o1 = AOP_RRR(OP_MFCR, uint32(p.To.Reg), 0, 0) /* old form, whole register */
3446                 }
3447
3448         case 69: /* mtcrf CRM,rS */
3449                 var v int32
3450                 if p.From3Type() != obj.TYPE_NONE {
3451                         if p.To.Reg != 0 {
3452                                 c.ctxt.Diag("can't use both mask and CR(n)\n%v", p)
3453                         }
3454                         v = c.regoff(p.GetFrom3()) & 0xff
3455                 } else {
3456                         if p.To.Reg == 0 {
3457                                 v = 0xff /* CR */
3458                         } else {
3459                                 v = 1 << uint(7-(p.To.Reg&7)) /* CR(n) */
3460                         }
3461                 }
3462
3463                 o1 = AOP_RRR(OP_MTCRF, uint32(p.From.Reg), 0, 0) | uint32(v)<<12
3464
3465         case 70: /* [f]cmp r,r,cr*/
3466                 var r int
3467                 if p.Reg == 0 {
3468                         r = 0
3469                 } else {
3470                         r = (int(p.Reg) & 7) << 2
3471                 }
3472                 o1 = AOP_RRR(c.oprrr(p.As), uint32(r), uint32(p.From.Reg), uint32(p.To.Reg))
3473
3474         case 71: /* cmp[l] r,i,cr*/
3475                 var r int
3476                 if p.Reg == 0 {
3477                         r = 0
3478                 } else {
3479                         r = (int(p.Reg) & 7) << 2
3480                 }
3481                 o1 = AOP_RRR(c.opirr(p.As), uint32(r), uint32(p.From.Reg), 0) | uint32(c.regoff(&p.To))&0xffff
3482
3483         case 72: /* slbmte (Rb+Rs -> slb[Rb]) -> Rs, Rb */
3484                 o1 = AOP_RRR(c.oprrr(p.As), uint32(p.From.Reg), 0, uint32(p.To.Reg))
3485
3486         case 73: /* mcrfs crfD,crfS */
3487                 if p.From.Type != obj.TYPE_REG || p.From.Reg != REG_FPSCR || p.To.Type != obj.TYPE_REG || p.To.Reg < REG_CR0 || REG_CR7 < p.To.Reg {
3488                         c.ctxt.Diag("illegal FPSCR/CR field number\n%v", p)
3489                 }
3490                 o1 = AOP_RRR(OP_MCRFS, ((uint32(p.To.Reg) & 7) << 2), ((0 & 7) << 2), 0)
3491
3492         case 77: /* syscall $scon, syscall Rx */
3493                 if p.From.Type == obj.TYPE_CONST {
3494                         if p.From.Offset > BIG || p.From.Offset < -BIG {
3495                                 c.ctxt.Diag("illegal syscall, sysnum too large: %v", p)
3496                         }
3497                         o1 = AOP_IRR(OP_ADDI, REGZERO, REGZERO, uint32(p.From.Offset))
3498                 } else if p.From.Type == obj.TYPE_REG {
3499                         o1 = LOP_RRR(OP_OR, REGZERO, uint32(p.From.Reg), uint32(p.From.Reg))
3500                 } else {
3501                         c.ctxt.Diag("illegal syscall: %v", p)
3502                         o1 = 0x7fe00008 // trap always
3503                 }
3504
3505                 o2 = c.oprrr(p.As)
3506                 o3 = AOP_RRR(c.oprrr(AXOR), REGZERO, REGZERO, REGZERO) // XOR R0, R0
3507
3508         case 78: /* undef */
3509                 o1 = 0 /* "An instruction consisting entirely of binary 0s is guaranteed
3510                    always to be an illegal instruction."  */
3511
3512         /* relocation operations */
3513         case 74:
3514                 v := c.vregoff(&p.To)
3515                 // Offsets in DS form stores must be a multiple of 4
3516                 inst := c.opstore(p.As)
3517                 if c.opform(inst) == DS_FORM && v&0x3 != 0 {
3518                         log.Fatalf("invalid offset for DS form load/store %v", p)
3519                 }
3520                 o1, o2 = c.symbolAccess(p.To.Sym, v, p.From.Reg, inst)
3521
3522         //if(dlm) reloc(&p->to, p->pc, 1);
3523
3524         case 75:
3525                 v := c.vregoff(&p.From)
3526                 // Offsets in DS form loads must be a multiple of 4
3527                 inst := c.opload(p.As)
3528                 if c.opform(inst) == DS_FORM && v&0x3 != 0 {
3529                         log.Fatalf("invalid offset for DS form load/store %v", p)
3530                 }
3531                 o1, o2 = c.symbolAccess(p.From.Sym, v, p.To.Reg, inst)
3532
3533         //if(dlm) reloc(&p->from, p->pc, 1);
3534
3535         case 76:
3536                 v := c.vregoff(&p.From)
3537                 // Offsets in DS form loads must be a multiple of 4
3538                 inst := c.opload(p.As)
3539                 if c.opform(inst) == DS_FORM && v&0x3 != 0 {
3540                         log.Fatalf("invalid offset for DS form load/store %v", p)
3541                 }
3542                 o1, o2 = c.symbolAccess(p.From.Sym, v, p.To.Reg, inst)
3543                 o3 = LOP_RRR(OP_EXTSB, uint32(p.To.Reg), uint32(p.To.Reg), 0)
3544
3545                 //if(dlm) reloc(&p->from, p->pc, 1);
3546
3547         case 79:
3548                 if p.From.Offset != 0 {
3549                         c.ctxt.Diag("invalid offset against tls var %v", p)
3550                 }
3551                 o1 = AOP_IRR(OP_ADDI, uint32(p.To.Reg), REGZERO, 0)
3552                 rel := obj.Addrel(c.cursym)
3553                 rel.Off = int32(c.pc)
3554                 rel.Siz = 4
3555                 rel.Sym = p.From.Sym
3556                 rel.Type = objabi.R_POWER_TLS_LE
3557
3558         case 80:
3559                 if p.From.Offset != 0 {
3560                         c.ctxt.Diag("invalid offset against tls var %v", p)
3561                 }
3562                 o1 = AOP_IRR(OP_ADDIS, uint32(p.To.Reg), REG_R2, 0)
3563                 o2 = AOP_IRR(c.opload(AMOVD), uint32(p.To.Reg), uint32(p.To.Reg), 0)
3564                 rel := obj.Addrel(c.cursym)
3565                 rel.Off = int32(c.pc)
3566                 rel.Siz = 8
3567                 rel.Sym = p.From.Sym
3568                 rel.Type = objabi.R_POWER_TLS_IE
3569
3570         case 81:
3571                 v := c.vregoff(&p.To)
3572                 if v != 0 {
3573                         c.ctxt.Diag("invalid offset against GOT slot %v", p)
3574                 }
3575
3576                 o1 = AOP_IRR(OP_ADDIS, uint32(p.To.Reg), REG_R2, 0)
3577                 o2 = AOP_IRR(c.opload(AMOVD), uint32(p.To.Reg), uint32(p.To.Reg), 0)
3578                 rel := obj.Addrel(c.cursym)
3579                 rel.Off = int32(c.pc)
3580                 rel.Siz = 8
3581                 rel.Sym = p.From.Sym
3582                 rel.Type = objabi.R_ADDRPOWER_GOT
3583         case 82: /* vector instructions, VX-form and VC-form */
3584                 if p.From.Type == obj.TYPE_REG {
3585                         /* reg reg none OR reg reg reg */
3586                         /* 3-register operand order: VRA, VRB, VRT */
3587                         /* 2-register operand order: VRA, VRT */
3588                         o1 = AOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.Reg))
3589                 } else if p.From3Type() == obj.TYPE_CONST {
3590                         /* imm imm reg reg */
3591                         /* operand order: SIX, VRA, ST, VRT */
3592                         six := int(c.regoff(&p.From))
3593                         st := int(c.regoff(p.GetFrom3()))
3594                         o1 = AOP_IIRR(c.opiirr(p.As), uint32(p.To.Reg), uint32(p.Reg), uint32(st), uint32(six))
3595                 } else if p.From3Type() == obj.TYPE_NONE && p.Reg != 0 {
3596                         /* imm reg reg */
3597                         /* operand order: UIM, VRB, VRT */
3598                         uim := int(c.regoff(&p.From))
3599                         o1 = AOP_VIRR(c.opirr(p.As), uint32(p.To.Reg), uint32(p.Reg), uint32(uim))
3600                 } else {
3601                         /* imm reg */
3602                         /* operand order: SIM, VRT */
3603                         sim := int(c.regoff(&p.From))
3604                         o1 = AOP_IR(c.opirr(p.As), uint32(p.To.Reg), uint32(sim))
3605                 }
3606
3607         case 83: /* vector instructions, VA-form */
3608                 if p.From.Type == obj.TYPE_REG {
3609                         /* reg reg reg reg */
3610                         /* 4-register operand order: VRA, VRB, VRC, VRT */
3611                         o1 = AOP_RRRR(c.oprrr(p.As), uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.Reg), uint32(p.GetFrom3().Reg))
3612                 } else if p.From.Type == obj.TYPE_CONST {
3613                         /* imm reg reg reg */
3614                         /* operand order: SHB, VRA, VRB, VRT */
3615                         shb := int(c.regoff(&p.From))
3616                         o1 = AOP_IRRR(c.opirrr(p.As), uint32(p.To.Reg), uint32(p.Reg), uint32(p.GetFrom3().Reg), uint32(shb))
3617                 }
3618
3619         case 84: // ISEL BC,RA,RB,RT -> isel rt,ra,rb,bc
3620                 bc := c.vregoff(&p.From)
3621
3622                 // rt = To.Reg, ra = p.Reg, rb = p.From3.Reg
3623                 o1 = AOP_ISEL(OP_ISEL, uint32(p.To.Reg), uint32(p.Reg), uint32(p.GetFrom3().Reg), uint32(bc))
3624
3625         case 85: /* vector instructions, VX-form */
3626                 /* reg none reg */
3627                 /* 2-register operand order: VRB, VRT */
3628                 o1 = AOP_RR(c.oprrr(p.As), uint32(p.To.Reg), uint32(p.From.Reg))
3629
3630         case 86: /* VSX indexed store, XX1-form */
3631                 /* reg reg reg */
3632                 /* 3-register operand order: XT, (RB)(RA*1) */
3633                 o1 = AOP_XX1(c.opstorex(p.As), uint32(p.From.Reg), uint32(p.To.Index), uint32(p.To.Reg))
3634
3635         case 87: /* VSX indexed load, XX1-form */
3636                 /* reg reg reg */
3637                 /* 3-register operand order: (RB)(RA*1), XT */
3638                 o1 = AOP_XX1(c.oploadx(p.As), uint32(p.To.Reg), uint32(p.From.Index), uint32(p.From.Reg))
3639
3640         case 88: /* VSX instructions, XX1-form */
3641                 /* reg reg none OR reg reg reg */
3642                 /* 3-register operand order: RA, RB, XT */
3643                 /* 2-register operand order: XS, RA or RA, XT */
3644                 xt := int32(p.To.Reg)
3645                 xs := int32(p.From.Reg)
3646                 /* We need to treat the special case of extended mnemonics that may have a FREG/VREG as an argument */
3647                 if REG_V0 <= xt && xt <= REG_V31 {
3648                         /* Convert V0-V31 to VS32-VS63 */
3649                         xt = xt + 64
3650                         o1 = AOP_XX1(c.oprrr(p.As), uint32(xt), uint32(p.From.Reg), uint32(p.Reg))
3651                 } else if REG_F0 <= xt && xt <= REG_F31 {
3652                         /* Convert F0-F31 to VS0-VS31 */
3653                         xt = xt + 64
3654                         o1 = AOP_XX1(c.oprrr(p.As), uint32(xt), uint32(p.From.Reg), uint32(p.Reg))
3655                 } else if REG_VS0 <= xt && xt <= REG_VS63 {
3656                         o1 = AOP_XX1(c.oprrr(p.As), uint32(xt), uint32(p.From.Reg), uint32(p.Reg))
3657                 } else if REG_V0 <= xs && xs <= REG_V31 {
3658                         /* Likewise for XS */
3659                         xs = xs + 64
3660                         o1 = AOP_XX1(c.oprrr(p.As), uint32(xs), uint32(p.To.Reg), uint32(p.Reg))
3661                 } else if REG_F0 <= xs && xs <= REG_F31 {
3662                         xs = xs + 64
3663                         o1 = AOP_XX1(c.oprrr(p.As), uint32(xs), uint32(p.To.Reg), uint32(p.Reg))
3664                 } else if REG_VS0 <= xs && xs <= REG_VS63 {
3665                         o1 = AOP_XX1(c.oprrr(p.As), uint32(xs), uint32(p.To.Reg), uint32(p.Reg))
3666                 }
3667
3668         case 89: /* VSX instructions, XX2-form */
3669                 /* reg none reg OR reg imm reg */
3670                 /* 2-register operand order: XB, XT or XB, UIM, XT*/
3671                 uim := int(c.regoff(p.GetFrom3()))
3672                 o1 = AOP_XX2(c.oprrr(p.As), uint32(p.To.Reg), uint32(uim), uint32(p.From.Reg))
3673
3674         case 90: /* VSX instructions, XX3-form */
3675                 if p.From3Type() == obj.TYPE_NONE {
3676                         /* reg reg reg */
3677                         /* 3-register operand order: XA, XB, XT */
3678                         o1 = AOP_XX3(c.oprrr(p.As), uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.Reg))
3679                 } else if p.From3Type() == obj.TYPE_CONST {
3680                         /* reg reg reg imm */
3681                         /* operand order: XA, XB, DM, XT */
3682                         dm := int(c.regoff(p.GetFrom3()))
3683                         o1 = AOP_XX3I(c.oprrr(p.As), uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.Reg), uint32(dm))
3684                 }
3685
3686         case 91: /* VSX instructions, XX4-form */
3687                 /* reg reg reg reg */
3688                 /* 3-register operand order: XA, XB, XC, XT */
3689                 o1 = AOP_XX4(c.oprrr(p.As), uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.Reg), uint32(p.GetFrom3().Reg))
3690
3691         case 92: /* X-form instructions, 3-operands */
3692                 if p.To.Type == obj.TYPE_CONST {
3693                         /* imm reg reg */
3694                         xf := int32(p.From.Reg)
3695                         if REG_F0 <= xf && xf <= REG_F31 {
3696                                 /* operand order: FRA, FRB, BF */
3697                                 bf := int(c.regoff(&p.To)) << 2
3698                                 o1 = AOP_RRR(c.opirr(p.As), uint32(bf), uint32(p.From.Reg), uint32(p.Reg))
3699                         } else {
3700                                 /* operand order: RA, RB, L */
3701                                 l := int(c.regoff(&p.To))
3702                                 o1 = AOP_RRR(c.opirr(p.As), uint32(l), uint32(p.From.Reg), uint32(p.Reg))
3703                         }
3704                 } else if p.From3Type() == obj.TYPE_CONST {
3705                         /* reg reg imm */
3706                         /* operand order: RB, L, RA */
3707                         l := int(c.regoff(p.GetFrom3()))
3708                         o1 = AOP_RRR(c.opirr(p.As), uint32(l), uint32(p.To.Reg), uint32(p.From.Reg))
3709                 } else if p.To.Type == obj.TYPE_REG {
3710                         cr := int32(p.To.Reg)
3711                         if REG_CR0 <= cr && cr <= REG_CR7 {
3712                                 /* cr reg reg */
3713                                 /* operand order: RA, RB, BF */
3714                                 bf := (int(p.To.Reg) & 7) << 2
3715                                 o1 = AOP_RRR(c.opirr(p.As), uint32(bf), uint32(p.From.Reg), uint32(p.Reg))
3716                         } else if p.From.Type == obj.TYPE_CONST {
3717                                 /* reg imm */
3718                                 /* operand order: L, RT */
3719                                 l := int(c.regoff(&p.From))
3720                                 o1 = AOP_RRR(c.opirr(p.As), uint32(p.To.Reg), uint32(l), uint32(p.Reg))
3721                         } else {
3722                                 switch p.As {
3723                                 case ACOPY, APASTECC:
3724                                         o1 = AOP_RRR(c.opirr(p.As), uint32(1), uint32(p.From.Reg), uint32(p.To.Reg))
3725                                 default:
3726                                         /* reg reg reg */
3727                                         /* operand order: RS, RB, RA */
3728                                         o1 = AOP_RRR(c.oprrr(p.As), uint32(p.From.Reg), uint32(p.To.Reg), uint32(p.Reg))
3729                                 }
3730                         }
3731                 }
3732
3733         case 93: /* X-form instructions, 2-operands */
3734                 if p.To.Type == obj.TYPE_CONST {
3735                         /* imm reg */
3736                         /* operand order: FRB, BF */
3737                         bf := int(c.regoff(&p.To)) << 2
3738                         o1 = AOP_RR(c.opirr(p.As), uint32(bf), uint32(p.From.Reg))
3739                 } else if p.Reg == 0 {
3740                         /* popcnt* r,r, X-form */
3741                         /* operand order: RS, RA */
3742                         o1 = AOP_RRR(c.oprrr(p.As), uint32(p.From.Reg), uint32(p.To.Reg), uint32(p.Reg))
3743                 }
3744
3745         case 94: /* Z23-form instructions, 4-operands */
3746                 /* reg reg reg imm */
3747                 /* operand order: RA, RB, CY, RT */
3748                 cy := int(c.regoff(p.GetFrom3()))
3749                 o1 = AOP_Z23I(c.oprrr(p.As), uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.Reg), uint32(cy))
3750
3751         case 95: /* Retrieve TOC relative symbol */
3752                 /* This code is for AIX only */
3753                 v := c.vregoff(&p.From)
3754                 if v != 0 {
3755                         c.ctxt.Diag("invalid offset against TOC slot %v", p)
3756                 }
3757
3758                 inst := c.opload(p.As)
3759                 if c.opform(inst) != DS_FORM {
3760                         c.ctxt.Diag("invalid form for a TOC access in %v", p)
3761                 }
3762
3763                 o1 = AOP_IRR(OP_ADDIS, uint32(p.To.Reg), REG_R2, 0)
3764                 o2 = AOP_IRR(inst, uint32(p.To.Reg), uint32(p.To.Reg), 0)
3765                 rel := obj.Addrel(c.cursym)
3766                 rel.Off = int32(c.pc)
3767                 rel.Siz = 8
3768                 rel.Sym = p.From.Sym
3769                 rel.Type = objabi.R_ADDRPOWER_TOCREL_DS
3770
3771         case 96: /* VSX load, DQ-form */
3772                 /* reg imm reg */
3773                 /* operand order: (RA)(DQ), XT */
3774                 dq := int16(c.regoff(&p.From))
3775                 if (dq & 15) != 0 {
3776                         c.ctxt.Diag("invalid offset for DQ form load/store %v", dq)
3777                 }
3778                 o1 = AOP_DQ(c.opload(p.As), uint32(p.To.Reg), uint32(p.From.Reg), uint32(dq))
3779
3780         case 97: /* VSX store, DQ-form */
3781                 /* reg imm reg */
3782                 /* operand order: XT, (RA)(DQ) */
3783                 dq := int16(c.regoff(&p.To))
3784                 if (dq & 15) != 0 {
3785                         c.ctxt.Diag("invalid offset for DQ form load/store %v", dq)
3786                 }
3787                 o1 = AOP_DQ(c.opstore(p.As), uint32(p.From.Reg), uint32(p.To.Reg), uint32(dq))
3788         case 98: /* VSX indexed load or load with length (also left-justified), x-form */
3789                 /* vsreg, reg, reg */
3790                 o1 = AOP_XX1(c.opload(p.As), uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.Reg))
3791         case 99: /* VSX store with length (also left-justified) x-form */
3792                 /* reg, reg, vsreg */
3793                 o1 = AOP_XX1(c.opstore(p.As), uint32(p.From.Reg), uint32(p.Reg), uint32(p.To.Reg))
3794         case 100: /* VSX X-form XXSPLTIB */
3795                 if p.From.Type == obj.TYPE_CONST {
3796                         /* imm reg */
3797                         uim := int(c.regoff(&p.From))
3798                         /* imm reg */
3799                         /* Use AOP_XX1 form with 0 for one of the registers. */
3800                         o1 = AOP_XX1(c.oprrr(p.As), uint32(p.To.Reg), uint32(0), uint32(uim))
3801                 } else {
3802                         c.ctxt.Diag("invalid ops for %v", p.As)
3803                 }
3804         case 101:
3805                 o1 = AOP_XX2(c.oprrr(p.As), uint32(p.To.Reg), uint32(0), uint32(p.From.Reg))
3806
3807         case 102: /* RLWMI $sh,rs,$mb,$me,rt (M-form opcode)*/
3808                 mb := uint32(c.regoff(&p.RestArgs[0].Addr))
3809                 me := uint32(c.regoff(&p.RestArgs[1].Addr))
3810                 sh := uint32(c.regoff(&p.From))
3811                 o1 = OP_RLW(c.opirr(p.As), uint32(p.To.Reg), uint32(p.Reg), sh, mb, me)
3812
3813         case 103: /* RLWMI rb,rs,$mb,$me,rt (M-form opcode)*/
3814                 mb := uint32(c.regoff(&p.RestArgs[0].Addr))
3815                 me := uint32(c.regoff(&p.RestArgs[1].Addr))
3816                 o1 = OP_RLW(c.oprrr(p.As), uint32(p.To.Reg), uint32(p.Reg), uint32(p.From.Reg), mb, me)
3817         }
3818
3819         out[0] = o1
3820         out[1] = o2
3821         out[2] = o3
3822         out[3] = o4
3823         out[4] = o5
3824 }
3825
3826 func (c *ctxt9) vregoff(a *obj.Addr) int64 {
3827         c.instoffset = 0
3828         if a != nil {
3829                 c.aclass(a)
3830         }
3831         return c.instoffset
3832 }
3833
3834 func (c *ctxt9) regoff(a *obj.Addr) int32 {
3835         return int32(c.vregoff(a))
3836 }
3837
3838 func (c *ctxt9) oprrr(a obj.As) uint32 {
3839         switch a {
3840         case AADD:
3841                 return OPVCC(31, 266, 0, 0)
3842         case AADDCC:
3843                 return OPVCC(31, 266, 0, 1)
3844         case AADDV:
3845                 return OPVCC(31, 266, 1, 0)
3846         case AADDVCC:
3847                 return OPVCC(31, 266, 1, 1)
3848         case AADDC:
3849                 return OPVCC(31, 10, 0, 0)
3850         case AADDCCC:
3851                 return OPVCC(31, 10, 0, 1)
3852         case AADDCV:
3853                 return OPVCC(31, 10, 1, 0)
3854         case AADDCVCC:
3855                 return OPVCC(31, 10, 1, 1)
3856         case AADDE:
3857                 return OPVCC(31, 138, 0, 0)
3858         case AADDECC:
3859                 return OPVCC(31, 138, 0, 1)
3860         case AADDEV:
3861                 return OPVCC(31, 138, 1, 0)
3862         case AADDEVCC:
3863                 return OPVCC(31, 138, 1, 1)
3864         case AADDME:
3865                 return OPVCC(31, 234, 0, 0)
3866         case AADDMECC:
3867                 return OPVCC(31, 234, 0, 1)
3868         case AADDMEV:
3869                 return OPVCC(31, 234, 1, 0)
3870         case AADDMEVCC:
3871                 return OPVCC(31, 234, 1, 1)
3872         case AADDZE:
3873                 return OPVCC(31, 202, 0, 0)
3874         case AADDZECC:
3875                 return OPVCC(31, 202, 0, 1)
3876         case AADDZEV:
3877                 return OPVCC(31, 202, 1, 0)
3878         case AADDZEVCC:
3879                 return OPVCC(31, 202, 1, 1)
3880         case AADDEX:
3881                 return OPVCC(31, 170, 0, 0) /* addex - v3.0b */
3882
3883         case AAND:
3884                 return OPVCC(31, 28, 0, 0)
3885         case AANDCC:
3886                 return OPVCC(31, 28, 0, 1)
3887         case AANDN:
3888                 return OPVCC(31, 60, 0, 0)
3889         case AANDNCC:
3890                 return OPVCC(31, 60, 0, 1)
3891
3892         case ACMP:
3893                 return OPVCC(31, 0, 0, 0) | 1<<21 /* L=1 */
3894         case ACMPU:
3895                 return OPVCC(31, 32, 0, 0) | 1<<21
3896         case ACMPW:
3897                 return OPVCC(31, 0, 0, 0) /* L=0 */
3898         case ACMPWU:
3899                 return OPVCC(31, 32, 0, 0)
3900         case ACMPB:
3901                 return OPVCC(31, 508, 0, 0) /* cmpb - v2.05 */
3902         case ACMPEQB:
3903                 return OPVCC(31, 224, 0, 0) /* cmpeqb - v3.00 */
3904
3905         case ACNTLZW:
3906                 return OPVCC(31, 26, 0, 0)
3907         case ACNTLZWCC:
3908                 return OPVCC(31, 26, 0, 1)
3909         case ACNTLZD:
3910                 return OPVCC(31, 58, 0, 0)
3911         case ACNTLZDCC:
3912                 return OPVCC(31, 58, 0, 1)
3913
3914         case ACRAND:
3915                 return OPVCC(19, 257, 0, 0)
3916         case ACRANDN:
3917                 return OPVCC(19, 129, 0, 0)
3918         case ACREQV:
3919                 return OPVCC(19, 289, 0, 0)
3920         case ACRNAND:
3921                 return OPVCC(19, 225, 0, 0)
3922         case ACRNOR:
3923                 return OPVCC(19, 33, 0, 0)
3924         case ACROR:
3925                 return OPVCC(19, 449, 0, 0)
3926         case ACRORN:
3927                 return OPVCC(19, 417, 0, 0)
3928         case ACRXOR:
3929                 return OPVCC(19, 193, 0, 0)
3930
3931         case ADCBF:
3932                 return OPVCC(31, 86, 0, 0)
3933         case ADCBI:
3934                 return OPVCC(31, 470, 0, 0)
3935         case ADCBST:
3936                 return OPVCC(31, 54, 0, 0)
3937         case ADCBT:
3938                 return OPVCC(31, 278, 0, 0)
3939         case ADCBTST:
3940                 return OPVCC(31, 246, 0, 0)
3941         case ADCBZ:
3942                 return OPVCC(31, 1014, 0, 0)
3943
3944         case AMODUD:
3945                 return OPVCC(31, 265, 0, 0) /* modud - v3.0 */
3946         case AMODUW:
3947                 return OPVCC(31, 267, 0, 0) /* moduw - v3.0 */
3948         case AMODSD:
3949                 return OPVCC(31, 777, 0, 0) /* modsd - v3.0 */
3950         case AMODSW:
3951                 return OPVCC(31, 779, 0, 0) /* modsw - v3.0 */
3952
3953         case ADIVW, AREM:
3954                 return OPVCC(31, 491, 0, 0)
3955
3956         case ADIVWCC:
3957                 return OPVCC(31, 491, 0, 1)
3958
3959         case ADIVWV:
3960                 return OPVCC(31, 491, 1, 0)
3961
3962         case ADIVWVCC:
3963                 return OPVCC(31, 491, 1, 1)
3964
3965         case ADIVWU, AREMU:
3966                 return OPVCC(31, 459, 0, 0)
3967
3968         case ADIVWUCC:
3969                 return OPVCC(31, 459, 0, 1)
3970
3971         case ADIVWUV:
3972                 return OPVCC(31, 459, 1, 0)
3973
3974         case ADIVWUVCC:
3975                 return OPVCC(31, 459, 1, 1)
3976
3977         case ADIVD, AREMD:
3978                 return OPVCC(31, 489, 0, 0)
3979
3980         case ADIVDCC:
3981                 return OPVCC(31, 489, 0, 1)
3982
3983         case ADIVDE:
3984                 return OPVCC(31, 425, 0, 0)
3985
3986         case ADIVDECC:
3987                 return OPVCC(31, 425, 0, 1)
3988
3989         case ADIVDEU:
3990                 return OPVCC(31, 393, 0, 0)
3991
3992         case ADIVDEUCC:
3993                 return OPVCC(31, 393, 0, 1)
3994
3995         case ADIVDV:
3996                 return OPVCC(31, 489, 1, 0)
3997
3998         case ADIVDVCC:
3999                 return OPVCC(31, 489, 1, 1)
4000
4001         case ADIVDU, AREMDU:
4002                 return OPVCC(31, 457, 0, 0)
4003
4004         case ADIVDUCC:
4005                 return OPVCC(31, 457, 0, 1)
4006
4007         case ADIVDUV:
4008                 return OPVCC(31, 457, 1, 0)
4009
4010         case ADIVDUVCC:
4011                 return OPVCC(31, 457, 1, 1)
4012
4013         case AEIEIO:
4014                 return OPVCC(31, 854, 0, 0)
4015
4016         case AEQV:
4017                 return OPVCC(31, 284, 0, 0)
4018         case AEQVCC:
4019                 return OPVCC(31, 284, 0, 1)
4020
4021         case AEXTSB:
4022                 return OPVCC(31, 954, 0, 0)
4023         case AEXTSBCC:
4024                 return OPVCC(31, 954, 0, 1)
4025         case AEXTSH:
4026                 return OPVCC(31, 922, 0, 0)
4027         case AEXTSHCC:
4028                 return OPVCC(31, 922, 0, 1)
4029         case AEXTSW:
4030                 return OPVCC(31, 986, 0, 0)
4031         case AEXTSWCC:
4032                 return OPVCC(31, 986, 0, 1)
4033
4034         case AFABS:
4035                 return OPVCC(63, 264, 0, 0)
4036         case AFABSCC:
4037                 return OPVCC(63, 264, 0, 1)
4038         case AFADD:
4039                 return OPVCC(63, 21, 0, 0)
4040         case AFADDCC:
4041                 return OPVCC(63, 21, 0, 1)
4042         case AFADDS:
4043                 return OPVCC(59, 21, 0, 0)
4044         case AFADDSCC:
4045                 return OPVCC(59, 21, 0, 1)
4046         case AFCMPO:
4047                 return OPVCC(63, 32, 0, 0)
4048         case AFCMPU:
4049                 return OPVCC(63, 0, 0, 0)
4050         case AFCFID:
4051                 return OPVCC(63, 846, 0, 0)
4052         case AFCFIDCC:
4053                 return OPVCC(63, 846, 0, 1)
4054         case AFCFIDU:
4055                 return OPVCC(63, 974, 0, 0)
4056         case AFCFIDUCC:
4057                 return OPVCC(63, 974, 0, 1)
4058         case AFCFIDS:
4059                 return OPVCC(59, 846, 0, 0)
4060         case AFCFIDSCC:
4061                 return OPVCC(59, 846, 0, 1)
4062         case AFCTIW:
4063                 return OPVCC(63, 14, 0, 0)
4064         case AFCTIWCC:
4065                 return OPVCC(63, 14, 0, 1)
4066         case AFCTIWZ:
4067                 return OPVCC(63, 15, 0, 0)
4068         case AFCTIWZCC:
4069                 return OPVCC(63, 15, 0, 1)
4070         case AFCTID:
4071                 return OPVCC(63, 814, 0, 0)
4072         case AFCTIDCC:
4073                 return OPVCC(63, 814, 0, 1)
4074         case AFCTIDZ:
4075                 return OPVCC(63, 815, 0, 0)
4076         case AFCTIDZCC:
4077                 return OPVCC(63, 815, 0, 1)
4078         case AFDIV:
4079                 return OPVCC(63, 18, 0, 0)
4080         case AFDIVCC:
4081                 return OPVCC(63, 18, 0, 1)
4082         case AFDIVS:
4083                 return OPVCC(59, 18, 0, 0)
4084         case AFDIVSCC:
4085                 return OPVCC(59, 18, 0, 1)
4086         case AFMADD:
4087                 return OPVCC(63, 29, 0, 0)
4088         case AFMADDCC:
4089                 return OPVCC(63, 29, 0, 1)
4090         case AFMADDS:
4091                 return OPVCC(59, 29, 0, 0)
4092         case AFMADDSCC:
4093                 return OPVCC(59, 29, 0, 1)
4094
4095         case AFMOVS, AFMOVD:
4096                 return OPVCC(63, 72, 0, 0) /* load */
4097         case AFMOVDCC:
4098                 return OPVCC(63, 72, 0, 1)
4099         case AFMSUB:
4100                 return OPVCC(63, 28, 0, 0)
4101         case AFMSUBCC:
4102                 return OPVCC(63, 28, 0, 1)
4103         case AFMSUBS:
4104                 return OPVCC(59, 28, 0, 0)
4105         case AFMSUBSCC:
4106                 return OPVCC(59, 28, 0, 1)
4107         case AFMUL:
4108                 return OPVCC(63, 25, 0, 0)
4109         case AFMULCC:
4110                 return OPVCC(63, 25, 0, 1)
4111         case AFMULS:
4112                 return OPVCC(59, 25, 0, 0)
4113         case AFMULSCC:
4114                 return OPVCC(59, 25, 0, 1)
4115         case AFNABS:
4116                 return OPVCC(63, 136, 0, 0)
4117         case AFNABSCC:
4118                 return OPVCC(63, 136, 0, 1)
4119         case AFNEG:
4120                 return OPVCC(63, 40, 0, 0)
4121         case AFNEGCC:
4122                 return OPVCC(63, 40, 0, 1)
4123         case AFNMADD:
4124                 return OPVCC(63, 31, 0, 0)
4125         case AFNMADDCC:
4126                 return OPVCC(63, 31, 0, 1)
4127         case AFNMADDS:
4128                 return OPVCC(59, 31, 0, 0)
4129         case AFNMADDSCC:
4130                 return OPVCC(59, 31, 0, 1)
4131         case AFNMSUB:
4132                 return OPVCC(63, 30, 0, 0)
4133         case AFNMSUBCC:
4134                 return OPVCC(63, 30, 0, 1)
4135         case AFNMSUBS:
4136                 return OPVCC(59, 30, 0, 0)
4137         case AFNMSUBSCC:
4138                 return OPVCC(59, 30, 0, 1)
4139         case AFCPSGN:
4140                 return OPVCC(63, 8, 0, 0)
4141         case AFCPSGNCC:
4142                 return OPVCC(63, 8, 0, 1)
4143         case AFRES:
4144                 return OPVCC(59, 24, 0, 0)
4145         case AFRESCC:
4146                 return OPVCC(59, 24, 0, 1)
4147         case AFRIM:
4148                 return OPVCC(63, 488, 0, 0)
4149         case AFRIMCC:
4150                 return OPVCC(63, 488, 0, 1)
4151         case AFRIP:
4152                 return OPVCC(63, 456, 0, 0)
4153         case AFRIPCC:
4154                 return OPVCC(63, 456, 0, 1)
4155         case AFRIZ:
4156                 return OPVCC(63, 424, 0, 0)
4157         case AFRIZCC:
4158                 return OPVCC(63, 424, 0, 1)
4159         case AFRIN:
4160                 return OPVCC(63, 392, 0, 0)
4161         case AFRINCC:
4162                 return OPVCC(63, 392, 0, 1)
4163         case AFRSP:
4164                 return OPVCC(63, 12, 0, 0)
4165         case AFRSPCC:
4166                 return OPVCC(63, 12, 0, 1)
4167         case AFRSQRTE:
4168                 return OPVCC(63, 26, 0, 0)
4169         case AFRSQRTECC:
4170                 return OPVCC(63, 26, 0, 1)
4171         case AFSEL:
4172                 return OPVCC(63, 23, 0, 0)
4173         case AFSELCC:
4174                 return OPVCC(63, 23, 0, 1)
4175         case AFSQRT:
4176                 return OPVCC(63, 22, 0, 0)
4177         case AFSQRTCC:
4178                 return OPVCC(63, 22, 0, 1)
4179         case AFSQRTS:
4180                 return OPVCC(59, 22, 0, 0)
4181         case AFSQRTSCC:
4182                 return OPVCC(59, 22, 0, 1)
4183         case AFSUB:
4184                 return OPVCC(63, 20, 0, 0)
4185         case AFSUBCC:
4186                 return OPVCC(63, 20, 0, 1)
4187         case AFSUBS:
4188                 return OPVCC(59, 20, 0, 0)
4189         case AFSUBSCC:
4190                 return OPVCC(59, 20, 0, 1)
4191
4192         case AICBI:
4193                 return OPVCC(31, 982, 0, 0)
4194         case AISYNC:
4195                 return OPVCC(19, 150, 0, 0)
4196
4197         case AMTFSB0:
4198                 return OPVCC(63, 70, 0, 0)
4199         case AMTFSB0CC:
4200                 return OPVCC(63, 70, 0, 1)
4201         case AMTFSB1:
4202                 return OPVCC(63, 38, 0, 0)
4203         case AMTFSB1CC:
4204                 return OPVCC(63, 38, 0, 1)
4205
4206         case AMULHW:
4207                 return OPVCC(31, 75, 0, 0)
4208         case AMULHWCC:
4209                 return OPVCC(31, 75, 0, 1)
4210         case AMULHWU:
4211                 return OPVCC(31, 11, 0, 0)
4212         case AMULHWUCC:
4213                 return OPVCC(31, 11, 0, 1)
4214         case AMULLW:
4215                 return OPVCC(31, 235, 0, 0)
4216         case AMULLWCC:
4217                 return OPVCC(31, 235, 0, 1)
4218         case AMULLWV:
4219                 return OPVCC(31, 235, 1, 0)
4220         case AMULLWVCC:
4221                 return OPVCC(31, 235, 1, 1)
4222
4223         case AMULHD:
4224                 return OPVCC(31, 73, 0, 0)
4225         case AMULHDCC:
4226                 return OPVCC(31, 73, 0, 1)
4227         case AMULHDU:
4228                 return OPVCC(31, 9, 0, 0)
4229         case AMULHDUCC:
4230                 return OPVCC(31, 9, 0, 1)
4231         case AMULLD:
4232                 return OPVCC(31, 233, 0, 0)
4233         case AMULLDCC:
4234                 return OPVCC(31, 233, 0, 1)
4235         case AMULLDV:
4236                 return OPVCC(31, 233, 1, 0)
4237         case AMULLDVCC:
4238                 return OPVCC(31, 233, 1, 1)
4239
4240         case ANAND:
4241                 return OPVCC(31, 476, 0, 0)
4242         case ANANDCC:
4243                 return OPVCC(31, 476, 0, 1)
4244         case ANEG:
4245                 return OPVCC(31, 104, 0, 0)
4246         case ANEGCC:
4247                 return OPVCC(31, 104, 0, 1)
4248         case ANEGV:
4249                 return OPVCC(31, 104, 1, 0)
4250         case ANEGVCC:
4251                 return OPVCC(31, 104, 1, 1)
4252         case ANOR:
4253                 return OPVCC(31, 124, 0, 0)
4254         case ANORCC:
4255                 return OPVCC(31, 124, 0, 1)
4256         case AOR:
4257                 return OPVCC(31, 444, 0, 0)
4258         case AORCC:
4259                 return OPVCC(31, 444, 0, 1)
4260         case AORN:
4261                 return OPVCC(31, 412, 0, 0)
4262         case AORNCC:
4263                 return OPVCC(31, 412, 0, 1)
4264
4265         case APOPCNTD:
4266                 return OPVCC(31, 506, 0, 0) /* popcntd - v2.06 */
4267         case APOPCNTW:
4268                 return OPVCC(31, 378, 0, 0) /* popcntw - v2.06 */
4269         case APOPCNTB:
4270                 return OPVCC(31, 122, 0, 0) /* popcntb - v2.02 */
4271         case ACNTTZW:
4272                 return OPVCC(31, 538, 0, 0) /* cnttzw - v3.00 */
4273         case ACNTTZWCC:
4274                 return OPVCC(31, 538, 0, 1) /* cnttzw. - v3.00 */
4275         case ACNTTZD:
4276                 return OPVCC(31, 570, 0, 0) /* cnttzd - v3.00 */
4277         case ACNTTZDCC:
4278                 return OPVCC(31, 570, 0, 1) /* cnttzd. - v3.00 */
4279
4280         case ARFI:
4281                 return OPVCC(19, 50, 0, 0)
4282         case ARFCI:
4283                 return OPVCC(19, 51, 0, 0)
4284         case ARFID:
4285                 return OPVCC(19, 18, 0, 0)
4286         case AHRFID:
4287                 return OPVCC(19, 274, 0, 0)
4288
4289         case ARLWMI:
4290                 return OPVCC(20, 0, 0, 0)
4291         case ARLWMICC:
4292                 return OPVCC(20, 0, 0, 1)
4293         case ARLWNM:
4294                 return OPVCC(23, 0, 0, 0)
4295         case ARLWNMCC:
4296                 return OPVCC(23, 0, 0, 1)
4297
4298         case ARLDCL:
4299                 return OPVCC(30, 8, 0, 0)
4300         case ARLDCLCC:
4301                 return OPVCC(30, 0, 0, 1)
4302
4303         case ARLDCR:
4304                 return OPVCC(30, 9, 0, 0)
4305         case ARLDCRCC:
4306                 return OPVCC(30, 9, 0, 1)
4307
4308         case ARLDICL:
4309                 return OPVCC(30, 0, 0, 0)
4310         case ARLDICLCC:
4311                 return OPVCC(30, 0, 0, 1)
4312         case ARLDICR:
4313                 return OPVCC(30, 0, 0, 0) | 2<<1 // rldicr
4314         case ARLDICRCC:
4315                 return OPVCC(30, 0, 0, 1) | 2<<1 // rldicr.
4316
4317         case ARLDIC:
4318                 return OPVCC(30, 0, 0, 0) | 4<<1 // rldic
4319         case ARLDICCC:
4320                 return OPVCC(30, 0, 0, 1) | 4<<1 // rldic.
4321
4322         case ASYSCALL:
4323                 return OPVCC(17, 1, 0, 0)
4324
4325         case ASLW:
4326                 return OPVCC(31, 24, 0, 0)
4327         case ASLWCC:
4328                 return OPVCC(31, 24, 0, 1)
4329         case ASLD:
4330                 return OPVCC(31, 27, 0, 0)
4331         case ASLDCC:
4332                 return OPVCC(31, 27, 0, 1)
4333
4334         case ASRAW:
4335                 return OPVCC(31, 792, 0, 0)
4336         case ASRAWCC:
4337                 return OPVCC(31, 792, 0, 1)
4338         case ASRAD:
4339                 return OPVCC(31, 794, 0, 0)
4340         case ASRADCC:
4341                 return OPVCC(31, 794, 0, 1)
4342
4343         case AEXTSWSLI:
4344                 return OPVCC(31, 445, 0, 0)
4345         case AEXTSWSLICC:
4346                 return OPVCC(31, 445, 0, 1)
4347
4348         case ASRW:
4349                 return OPVCC(31, 536, 0, 0)
4350         case ASRWCC:
4351                 return OPVCC(31, 536, 0, 1)
4352         case ASRD:
4353                 return OPVCC(31, 539, 0, 0)
4354         case ASRDCC:
4355                 return OPVCC(31, 539, 0, 1)
4356
4357         case ASUB:
4358                 return OPVCC(31, 40, 0, 0)
4359         case ASUBCC:
4360                 return OPVCC(31, 40, 0, 1)
4361         case ASUBV:
4362                 return OPVCC(31, 40, 1, 0)
4363         case ASUBVCC:
4364                 return OPVCC(31, 40, 1, 1)
4365         case ASUBC:
4366                 return OPVCC(31, 8, 0, 0)
4367         case ASUBCCC:
4368                 return OPVCC(31, 8, 0, 1)
4369         case ASUBCV:
4370                 return OPVCC(31, 8, 1, 0)
4371         case ASUBCVCC:
4372                 return OPVCC(31, 8, 1, 1)
4373         case ASUBE:
4374                 return OPVCC(31, 136, 0, 0)
4375         case ASUBECC:
4376                 return OPVCC(31, 136, 0, 1)
4377         case ASUBEV:
4378                 return OPVCC(31, 136, 1, 0)
4379         case ASUBEVCC:
4380                 return OPVCC(31, 136, 1, 1)
4381         case ASUBME:
4382                 return OPVCC(31, 232, 0, 0)
4383         case ASUBMECC:
4384                 return OPVCC(31, 232, 0, 1)
4385         case ASUBMEV:
4386                 return OPVCC(31, 232, 1, 0)
4387         case ASUBMEVCC:
4388                 return OPVCC(31, 232, 1, 1)
4389         case ASUBZE:
4390                 return OPVCC(31, 200, 0, 0)
4391         case ASUBZECC:
4392                 return OPVCC(31, 200, 0, 1)
4393         case ASUBZEV:
4394                 return OPVCC(31, 200, 1, 0)
4395         case ASUBZEVCC:
4396                 return OPVCC(31, 200, 1, 1)
4397
4398         case ASYNC:
4399                 return OPVCC(31, 598, 0, 0)
4400         case ALWSYNC:
4401                 return OPVCC(31, 598, 0, 0) | 1<<21
4402
4403         case APTESYNC:
4404                 return OPVCC(31, 598, 0, 0) | 2<<21
4405
4406         case ATLBIE:
4407                 return OPVCC(31, 306, 0, 0)
4408         case ATLBIEL:
4409                 return OPVCC(31, 274, 0, 0)
4410         case ATLBSYNC:
4411                 return OPVCC(31, 566, 0, 0)
4412         case ASLBIA:
4413                 return OPVCC(31, 498, 0, 0)
4414         case ASLBIE:
4415                 return OPVCC(31, 434, 0, 0)
4416         case ASLBMFEE:
4417                 return OPVCC(31, 915, 0, 0)
4418         case ASLBMFEV:
4419                 return OPVCC(31, 851, 0, 0)
4420         case ASLBMTE:
4421                 return OPVCC(31, 402, 0, 0)
4422
4423         case ATW:
4424                 return OPVCC(31, 4, 0, 0)
4425         case ATD:
4426                 return OPVCC(31, 68, 0, 0)
4427
4428         /* Vector (VMX/Altivec) instructions */
4429         /* ISA 2.03 enables these for PPC970. For POWERx processors, these */
4430         /* are enabled starting at POWER6 (ISA 2.05). */
4431         case AVAND:
4432                 return OPVX(4, 1028, 0, 0) /* vand - v2.03 */
4433         case AVANDC:
4434                 return OPVX(4, 1092, 0, 0) /* vandc - v2.03 */
4435         case AVNAND:
4436                 return OPVX(4, 1412, 0, 0) /* vnand - v2.07 */
4437
4438         case AVOR:
4439                 return OPVX(4, 1156, 0, 0) /* vor - v2.03 */
4440         case AVORC:
4441                 return OPVX(4, 1348, 0, 0) /* vorc - v2.07 */
4442         case AVNOR:
4443                 return OPVX(4, 1284, 0, 0) /* vnor - v2.03 */
4444         case AVXOR:
4445                 return OPVX(4, 1220, 0, 0) /* vxor - v2.03 */
4446         case AVEQV:
4447                 return OPVX(4, 1668, 0, 0) /* veqv - v2.07 */
4448
4449         case AVADDUBM:
4450                 return OPVX(4, 0, 0, 0) /* vaddubm - v2.03 */
4451         case AVADDUHM:
4452                 return OPVX(4, 64, 0, 0) /* vadduhm - v2.03 */
4453         case AVADDUWM:
4454                 return OPVX(4, 128, 0, 0) /* vadduwm - v2.03 */
4455         case AVADDUDM:
4456                 return OPVX(4, 192, 0, 0) /* vaddudm - v2.07 */
4457         case AVADDUQM:
4458                 return OPVX(4, 256, 0, 0) /* vadduqm - v2.07 */
4459
4460         case AVADDCUQ:
4461                 return OPVX(4, 320, 0, 0) /* vaddcuq - v2.07 */
4462         case AVADDCUW:
4463                 return OPVX(4, 384, 0, 0) /* vaddcuw - v2.03 */
4464
4465         case AVADDUBS:
4466                 return OPVX(4, 512, 0, 0) /* vaddubs - v2.03 */
4467         case AVADDUHS:
4468                 return OPVX(4, 576, 0, 0) /* vadduhs - v2.03 */
4469         case AVADDUWS:
4470                 return OPVX(4, 640, 0, 0) /* vadduws - v2.03 */
4471
4472         case AVADDSBS:
4473                 return OPVX(4, 768, 0, 0) /* vaddsbs - v2.03 */
4474         case AVADDSHS:
4475                 return OPVX(4, 832, 0, 0) /* vaddshs - v2.03 */
4476         case AVADDSWS:
4477                 return OPVX(4, 896, 0, 0) /* vaddsws - v2.03 */
4478
4479         case AVADDEUQM:
4480                 return OPVX(4, 60, 0, 0) /* vaddeuqm - v2.07 */
4481         case AVADDECUQ:
4482                 return OPVX(4, 61, 0, 0) /* vaddecuq - v2.07 */
4483
4484         case AVMULESB:
4485                 return OPVX(4, 776, 0, 0) /* vmulesb - v2.03 */
4486         case AVMULOSB:
4487                 return OPVX(4, 264, 0, 0) /* vmulosb - v2.03 */
4488         case AVMULEUB:
4489                 return OPVX(4, 520, 0, 0) /* vmuleub - v2.03 */
4490         case AVMULOUB:
4491                 return OPVX(4, 8, 0, 0) /* vmuloub - v2.03 */
4492         case AVMULESH:
4493                 return OPVX(4, 840, 0, 0) /* vmulesh - v2.03 */
4494         case AVMULOSH:
4495                 return OPVX(4, 328, 0, 0) /* vmulosh - v2.03 */
4496         case AVMULEUH:
4497                 return OPVX(4, 584, 0, 0) /* vmuleuh - v2.03 */
4498         case AVMULOUH:
4499                 return OPVX(4, 72, 0, 0) /* vmulouh - v2.03 */
4500         case AVMULESW:
4501                 return OPVX(4, 904, 0, 0) /* vmulesw - v2.07 */
4502         case AVMULOSW:
4503                 return OPVX(4, 392, 0, 0) /* vmulosw - v2.07 */
4504         case AVMULEUW:
4505                 return OPVX(4, 648, 0, 0) /* vmuleuw - v2.07 */
4506         case AVMULOUW:
4507                 return OPVX(4, 136, 0, 0) /* vmulouw - v2.07 */
4508         case AVMULUWM:
4509                 return OPVX(4, 137, 0, 0) /* vmuluwm - v2.07 */
4510
4511         case AVPMSUMB:
4512                 return OPVX(4, 1032, 0, 0) /* vpmsumb - v2.07 */
4513         case AVPMSUMH:
4514                 return OPVX(4, 1096, 0, 0) /* vpmsumh - v2.07 */
4515         case AVPMSUMW:
4516                 return OPVX(4, 1160, 0, 0) /* vpmsumw - v2.07 */
4517         case AVPMSUMD:
4518                 return OPVX(4, 1224, 0, 0) /* vpmsumd - v2.07 */
4519
4520         case AVMSUMUDM:
4521                 return OPVX(4, 35, 0, 0) /* vmsumudm - v3.00b */
4522
4523         case AVSUBUBM:
4524                 return OPVX(4, 1024, 0, 0) /* vsububm - v2.03 */
4525         case AVSUBUHM:
4526                 return OPVX(4, 1088, 0, 0) /* vsubuhm - v2.03 */
4527         case AVSUBUWM:
4528                 return OPVX(4, 1152, 0, 0) /* vsubuwm - v2.03 */
4529         case AVSUBUDM:
4530                 return OPVX(4, 1216, 0, 0) /* vsubudm - v2.07 */
4531         case AVSUBUQM:
4532                 return OPVX(4, 1280, 0, 0) /* vsubuqm - v2.07 */
4533
4534         case AVSUBCUQ:
4535                 return OPVX(4, 1344, 0, 0) /* vsubcuq - v2.07 */
4536         case AVSUBCUW:
4537                 return OPVX(4, 1408, 0, 0) /* vsubcuw - v2.03 */
4538
4539         case AVSUBUBS:
4540                 return OPVX(4, 1536, 0, 0) /* vsububs - v2.03 */
4541         case AVSUBUHS:
4542                 return OPVX(4, 1600, 0, 0) /* vsubuhs - v2.03 */
4543         case AVSUBUWS:
4544                 return OPVX(4, 1664, 0, 0) /* vsubuws - v2.03 */
4545
4546         case AVSUBSBS:
4547                 return OPVX(4, 1792, 0, 0) /* vsubsbs - v2.03 */
4548         case AVSUBSHS:
4549                 return OPVX(4, 1856, 0, 0) /* vsubshs - v2.03 */
4550         case AVSUBSWS:
4551                 return OPVX(4, 1920, 0, 0) /* vsubsws - v2.03 */
4552
4553         case AVSUBEUQM:
4554                 return OPVX(4, 62, 0, 0) /* vsubeuqm - v2.07 */
4555         case AVSUBECUQ:
4556                 return OPVX(4, 63, 0, 0) /* vsubecuq - v2.07 */
4557
4558         case AVRLB:
4559                 return OPVX(4, 4, 0, 0) /* vrlb - v2.03 */
4560         case AVRLH:
4561                 return OPVX(4, 68, 0, 0) /* vrlh - v2.03 */
4562         case AVRLW:
4563                 return OPVX(4, 132, 0, 0) /* vrlw - v2.03 */
4564         case AVRLD:
4565                 return OPVX(4, 196, 0, 0) /* vrld - v2.07 */
4566
4567         case AVMRGOW:
4568                 return OPVX(4, 1676, 0, 0) /* vmrgow - v2.07 */
4569         case AVMRGEW:
4570                 return OPVX(4, 1932, 0, 0) /* vmrgew - v2.07 */
4571
4572         case AVSLB:
4573                 return OPVX(4, 260, 0, 0) /* vslh - v2.03 */
4574         case AVSLH:
4575                 return OPVX(4, 324, 0, 0) /* vslh - v2.03 */
4576         case AVSLW:
4577                 return OPVX(4, 388, 0, 0) /* vslw - v2.03 */
4578         case AVSL:
4579                 return OPVX(4, 452, 0, 0) /* vsl - v2.03 */
4580         case AVSLO:
4581                 return OPVX(4, 1036, 0, 0) /* vsl - v2.03 */
4582         case AVSRB:
4583                 return OPVX(4, 516, 0, 0) /* vsrb - v2.03 */
4584         case AVSRH:
4585                 return OPVX(4, 580, 0, 0) /* vsrh - v2.03 */
4586         case AVSRW:
4587                 return OPVX(4, 644, 0, 0) /* vsrw - v2.03 */
4588         case AVSR:
4589                 return OPVX(4, 708, 0, 0) /* vsr - v2.03 */
4590         case AVSRO:
4591                 return OPVX(4, 1100, 0, 0) /* vsro - v2.03 */
4592         case AVSLD:
4593                 return OPVX(4, 1476, 0, 0) /* vsld - v2.07 */
4594         case AVSRD:
4595                 return OPVX(4, 1732, 0, 0) /* vsrd - v2.07 */
4596
4597         case AVSRAB:
4598                 return OPVX(4, 772, 0, 0) /* vsrab - v2.03 */
4599         case AVSRAH:
4600                 return OPVX(4, 836, 0, 0) /* vsrah - v2.03 */
4601         case AVSRAW:
4602                 return OPVX(4, 900, 0, 0) /* vsraw - v2.03 */
4603         case AVSRAD:
4604                 return OPVX(4, 964, 0, 0) /* vsrad - v2.07 */
4605
4606         case AVBPERMQ:
4607                 return OPVC(4, 1356, 0, 0) /* vbpermq - v2.07 */
4608         case AVBPERMD:
4609                 return OPVC(4, 1484, 0, 0) /* vbpermd - v3.00 */
4610
4611         case AVCLZB:
4612                 return OPVX(4, 1794, 0, 0) /* vclzb - v2.07 */
4613         case AVCLZH:
4614                 return OPVX(4, 1858, 0, 0) /* vclzh - v2.07 */
4615         case AVCLZW:
4616                 return OPVX(4, 1922, 0, 0) /* vclzw - v2.07 */
4617         case AVCLZD:
4618                 return OPVX(4, 1986, 0, 0) /* vclzd - v2.07 */
4619
4620         case AVPOPCNTB:
4621                 return OPVX(4, 1795, 0, 0) /* vpopcntb - v2.07 */
4622         case AVPOPCNTH:
4623                 return OPVX(4, 1859, 0, 0) /* vpopcnth - v2.07 */
4624         case AVPOPCNTW:
4625                 return OPVX(4, 1923, 0, 0) /* vpopcntw - v2.07 */
4626         case AVPOPCNTD:
4627                 return OPVX(4, 1987, 0, 0) /* vpopcntd - v2.07 */
4628
4629         case AVCMPEQUB:
4630                 return OPVC(4, 6, 0, 0) /* vcmpequb - v2.03 */
4631         case AVCMPEQUBCC:
4632                 return OPVC(4, 6, 0, 1) /* vcmpequb. - v2.03 */
4633         case AVCMPEQUH:
4634                 return OPVC(4, 70, 0, 0) /* vcmpequh - v2.03 */
4635         case AVCMPEQUHCC:
4636                 return OPVC(4, 70, 0, 1) /* vcmpequh. - v2.03 */
4637         case AVCMPEQUW:
4638                 return OPVC(4, 134, 0, 0) /* vcmpequw - v2.03 */
4639         case AVCMPEQUWCC:
4640                 return OPVC(4, 134, 0, 1) /* vcmpequw. - v2.03 */
4641         case AVCMPEQUD:
4642                 return OPVC(4, 199, 0, 0) /* vcmpequd - v2.07 */
4643         case AVCMPEQUDCC:
4644                 return OPVC(4, 199, 0, 1) /* vcmpequd. - v2.07 */
4645
4646         case AVCMPGTUB:
4647                 return OPVC(4, 518, 0, 0) /* vcmpgtub - v2.03 */
4648         case AVCMPGTUBCC:
4649                 return OPVC(4, 518, 0, 1) /* vcmpgtub. - v2.03 */
4650         case AVCMPGTUH:
4651                 return OPVC(4, 582, 0, 0) /* vcmpgtuh - v2.03 */
4652         case AVCMPGTUHCC:
4653                 return OPVC(4, 582, 0, 1) /* vcmpgtuh. - v2.03 */
4654         case AVCMPGTUW:
4655                 return OPVC(4, 646, 0, 0) /* vcmpgtuw - v2.03 */
4656         case AVCMPGTUWCC:
4657                 return OPVC(4, 646, 0, 1) /* vcmpgtuw. - v2.03 */
4658         case AVCMPGTUD:
4659                 return OPVC(4, 711, 0, 0) /* vcmpgtud - v2.07 */
4660         case AVCMPGTUDCC:
4661                 return OPVC(4, 711, 0, 1) /* vcmpgtud. v2.07 */
4662         case AVCMPGTSB:
4663                 return OPVC(4, 774, 0, 0) /* vcmpgtsb - v2.03 */
4664         case AVCMPGTSBCC:
4665                 return OPVC(4, 774, 0, 1) /* vcmpgtsb. - v2.03 */
4666         case AVCMPGTSH:
4667                 return OPVC(4, 838, 0, 0) /* vcmpgtsh - v2.03 */
4668         case AVCMPGTSHCC:
4669                 return OPVC(4, 838, 0, 1) /* vcmpgtsh. - v2.03 */
4670         case AVCMPGTSW:
4671                 return OPVC(4, 902, 0, 0) /* vcmpgtsw - v2.03 */
4672         case AVCMPGTSWCC:
4673                 return OPVC(4, 902, 0, 1) /* vcmpgtsw. - v2.03 */
4674         case AVCMPGTSD:
4675                 return OPVC(4, 967, 0, 0) /* vcmpgtsd - v2.07 */
4676         case AVCMPGTSDCC:
4677                 return OPVC(4, 967, 0, 1) /* vcmpgtsd. - v2.07 */
4678
4679         case AVCMPNEZB:
4680                 return OPVC(4, 263, 0, 0) /* vcmpnezb - v3.00 */
4681         case AVCMPNEZBCC:
4682                 return OPVC(4, 263, 0, 1) /* vcmpnezb. - v3.00 */
4683         case AVCMPNEB:
4684                 return OPVC(4, 7, 0, 0) /* vcmpneb - v3.00 */
4685         case AVCMPNEBCC:
4686                 return OPVC(4, 7, 0, 1) /* vcmpneb. - v3.00 */
4687         case AVCMPNEH:
4688                 return OPVC(4, 71, 0, 0) /* vcmpneh - v3.00 */
4689         case AVCMPNEHCC:
4690                 return OPVC(4, 71, 0, 1) /* vcmpneh. - v3.00 */
4691         case AVCMPNEW:
4692                 return OPVC(4, 135, 0, 0) /* vcmpnew - v3.00 */
4693         case AVCMPNEWCC:
4694                 return OPVC(4, 135, 0, 1) /* vcmpnew. - v3.00 */
4695
4696         case AVPERM:
4697                 return OPVX(4, 43, 0, 0) /* vperm - v2.03 */
4698         case AVPERMXOR:
4699                 return OPVX(4, 45, 0, 0) /* vpermxor - v2.03 */
4700         case AVPERMR:
4701                 return OPVX(4, 59, 0, 0) /* vpermr - v3.0 */
4702
4703         case AVSEL:
4704                 return OPVX(4, 42, 0, 0) /* vsel - v2.03 */
4705
4706         case AVCIPHER:
4707                 return OPVX(4, 1288, 0, 0) /* vcipher - v2.07 */
4708         case AVCIPHERLAST:
4709                 return OPVX(4, 1289, 0, 0) /* vcipherlast - v2.07 */
4710         case AVNCIPHER:
4711                 return OPVX(4, 1352, 0, 0) /* vncipher - v2.07 */
4712         case AVNCIPHERLAST:
4713                 return OPVX(4, 1353, 0, 0) /* vncipherlast - v2.07 */
4714         case AVSBOX:
4715                 return OPVX(4, 1480, 0, 0) /* vsbox - v2.07 */
4716         /* End of vector instructions */
4717
4718         /* Vector scalar (VSX) instructions */
4719         /* ISA 2.06 enables these for POWER7. */
4720         case AMFVSRD, AMFVRD, AMFFPRD:
4721                 return OPVXX1(31, 51, 0) /* mfvsrd - v2.07 */
4722         case AMFVSRWZ:
4723                 return OPVXX1(31, 115, 0) /* mfvsrwz - v2.07 */
4724         case AMFVSRLD:
4725                 return OPVXX1(31, 307, 0) /* mfvsrld - v3.00 */
4726
4727         case AMTVSRD, AMTFPRD, AMTVRD:
4728                 return OPVXX1(31, 179, 0) /* mtvsrd - v2.07 */
4729         case AMTVSRWA:
4730                 return OPVXX1(31, 211, 0) /* mtvsrwa - v2.07 */
4731         case AMTVSRWZ:
4732                 return OPVXX1(31, 243, 0) /* mtvsrwz - v2.07 */
4733         case AMTVSRDD:
4734                 return OPVXX1(31, 435, 0) /* mtvsrdd - v3.00 */
4735         case AMTVSRWS:
4736                 return OPVXX1(31, 403, 0) /* mtvsrws - v3.00 */
4737
4738         case AXXLAND:
4739                 return OPVXX3(60, 130, 0) /* xxland - v2.06 */
4740         case AXXLANDC:
4741                 return OPVXX3(60, 138, 0) /* xxlandc - v2.06 */
4742         case AXXLEQV:
4743                 return OPVXX3(60, 186, 0) /* xxleqv - v2.07 */
4744         case AXXLNAND:
4745                 return OPVXX3(60, 178, 0) /* xxlnand - v2.07 */
4746
4747         case AXXLORC:
4748                 return OPVXX3(60, 170, 0) /* xxlorc - v2.07 */
4749         case AXXLNOR:
4750                 return OPVXX3(60, 162, 0) /* xxlnor - v2.06 */
4751         case AXXLOR, AXXLORQ:
4752                 return OPVXX3(60, 146, 0) /* xxlor - v2.06 */
4753         case AXXLXOR:
4754                 return OPVXX3(60, 154, 0) /* xxlxor - v2.06 */
4755
4756         case AXXSEL:
4757                 return OPVXX4(60, 3, 0) /* xxsel - v2.06 */
4758
4759         case AXXMRGHW:
4760                 return OPVXX3(60, 18, 0) /* xxmrghw - v2.06 */
4761         case AXXMRGLW:
4762                 return OPVXX3(60, 50, 0) /* xxmrglw - v2.06 */
4763
4764         case AXXSPLTW:
4765                 return OPVXX2(60, 164, 0) /* xxspltw - v2.06 */
4766
4767         case AXXSPLTIB:
4768                 return OPVCC(60, 360, 0, 0) /* xxspltib - v3.0 */
4769
4770         case AXXPERM:
4771                 return OPVXX3(60, 26, 0) /* xxperm - v2.06 */
4772         case AXXPERMDI:
4773                 return OPVXX3(60, 10, 0) /* xxpermdi - v2.06 */
4774
4775         case AXXSLDWI:
4776                 return OPVXX3(60, 2, 0) /* xxsldwi - v2.06 */
4777
4778         case AXXBRQ:
4779                 return OPVXX2VA(60, 475, 31) /* xxbrq - v3.0 */
4780         case AXXBRD:
4781                 return OPVXX2VA(60, 475, 23) /* xxbrd - v3.0 */
4782         case AXXBRW:
4783                 return OPVXX2VA(60, 475, 15) /* xxbrw - v3.0 */
4784         case AXXBRH:
4785                 return OPVXX2VA(60, 475, 7) /* xxbrh - v3.0 */
4786
4787         case AXSCVDPSP:
4788                 return OPVXX2(60, 265, 0) /* xscvdpsp - v2.06 */
4789         case AXSCVSPDP:
4790                 return OPVXX2(60, 329, 0) /* xscvspdp - v2.06 */
4791         case AXSCVDPSPN:
4792                 return OPVXX2(60, 267, 0) /* xscvdpspn - v2.07 */
4793         case AXSCVSPDPN:
4794                 return OPVXX2(60, 331, 0) /* xscvspdpn - v2.07 */
4795
4796         case AXVCVDPSP:
4797                 return OPVXX2(60, 393, 0) /* xvcvdpsp - v2.06 */
4798         case AXVCVSPDP:
4799                 return OPVXX2(60, 457, 0) /* xvcvspdp - v2.06 */
4800
4801         case AXSCVDPSXDS:
4802                 return OPVXX2(60, 344, 0) /* xscvdpsxds - v2.06 */
4803         case AXSCVDPSXWS:
4804                 return OPVXX2(60, 88, 0) /* xscvdpsxws - v2.06 */
4805         case AXSCVDPUXDS:
4806                 return OPVXX2(60, 328, 0) /* xscvdpuxds - v2.06 */
4807         case AXSCVDPUXWS:
4808                 return OPVXX2(60, 72, 0) /* xscvdpuxws - v2.06 */
4809
4810         case AXSCVSXDDP:
4811                 return OPVXX2(60, 376, 0) /* xscvsxddp - v2.06 */
4812         case AXSCVUXDDP:
4813                 return OPVXX2(60, 360, 0) /* xscvuxddp - v2.06 */
4814         case AXSCVSXDSP:
4815                 return OPVXX2(60, 312, 0) /* xscvsxdsp - v2.06 */
4816         case AXSCVUXDSP:
4817                 return OPVXX2(60, 296, 0) /* xscvuxdsp - v2.06 */
4818
4819         case AXVCVDPSXDS:
4820                 return OPVXX2(60, 472, 0) /* xvcvdpsxds - v2.06 */
4821         case AXVCVDPSXWS:
4822                 return OPVXX2(60, 216, 0) /* xvcvdpsxws - v2.06 */
4823         case AXVCVDPUXDS:
4824                 return OPVXX2(60, 456, 0) /* xvcvdpuxds - v2.06 */
4825         case AXVCVDPUXWS:
4826                 return OPVXX2(60, 200, 0) /* xvcvdpuxws - v2.06 */
4827         case AXVCVSPSXDS:
4828                 return OPVXX2(60, 408, 0) /* xvcvspsxds - v2.07 */
4829         case AXVCVSPSXWS:
4830                 return OPVXX2(60, 152, 0) /* xvcvspsxws - v2.07 */
4831         case AXVCVSPUXDS:
4832                 return OPVXX2(60, 392, 0) /* xvcvspuxds - v2.07 */
4833         case AXVCVSPUXWS:
4834                 return OPVXX2(60, 136, 0) /* xvcvspuxws - v2.07 */
4835
4836         case AXVCVSXDDP:
4837                 return OPVXX2(60, 504, 0) /* xvcvsxddp - v2.06 */
4838         case AXVCVSXWDP:
4839                 return OPVXX2(60, 248, 0) /* xvcvsxwdp - v2.06 */
4840         case AXVCVUXDDP:
4841                 return OPVXX2(60, 488, 0) /* xvcvuxddp - v2.06 */
4842         case AXVCVUXWDP:
4843                 return OPVXX2(60, 232, 0) /* xvcvuxwdp - v2.06 */
4844         case AXVCVSXDSP:
4845                 return OPVXX2(60, 440, 0) /* xvcvsxdsp - v2.06 */
4846         case AXVCVSXWSP:
4847                 return OPVXX2(60, 184, 0) /* xvcvsxwsp - v2.06 */
4848         case AXVCVUXDSP:
4849                 return OPVXX2(60, 424, 0) /* xvcvuxdsp - v2.06 */
4850         case AXVCVUXWSP:
4851                 return OPVXX2(60, 168, 0) /* xvcvuxwsp - v2.06 */
4852         /* End of VSX instructions */
4853
4854         case AMADDHD:
4855                 return OPVX(4, 48, 0, 0) /* maddhd - v3.00 */
4856         case AMADDHDU:
4857                 return OPVX(4, 49, 0, 0) /* maddhdu - v3.00 */
4858         case AMADDLD:
4859                 return OPVX(4, 51, 0, 0) /* maddld - v3.00 */
4860
4861         case AXOR:
4862                 return OPVCC(31, 316, 0, 0)
4863         case AXORCC:
4864                 return OPVCC(31, 316, 0, 1)
4865         }
4866
4867         c.ctxt.Diag("bad r/r, r/r/r or r/r/r/r opcode %v", a)
4868         return 0
4869 }
4870
4871 func (c *ctxt9) opirrr(a obj.As) uint32 {
4872         switch a {
4873         /* Vector (VMX/Altivec) instructions */
4874         /* ISA 2.03 enables these for PPC970. For POWERx processors, these */
4875         /* are enabled starting at POWER6 (ISA 2.05). */
4876         case AVSLDOI:
4877                 return OPVX(4, 44, 0, 0) /* vsldoi - v2.03 */
4878         }
4879
4880         c.ctxt.Diag("bad i/r/r/r opcode %v", a)
4881         return 0
4882 }
4883
4884 func (c *ctxt9) opiirr(a obj.As) uint32 {
4885         switch a {
4886         /* Vector (VMX/Altivec) instructions */
4887         /* ISA 2.07 enables these for POWER8 and beyond. */
4888         case AVSHASIGMAW:
4889                 return OPVX(4, 1666, 0, 0) /* vshasigmaw - v2.07 */
4890         case AVSHASIGMAD:
4891                 return OPVX(4, 1730, 0, 0) /* vshasigmad - v2.07 */
4892         }
4893
4894         c.ctxt.Diag("bad i/i/r/r opcode %v", a)
4895         return 0
4896 }
4897
4898 func (c *ctxt9) opirr(a obj.As) uint32 {
4899         switch a {
4900         case AADD:
4901                 return OPVCC(14, 0, 0, 0)
4902         case AADDC:
4903                 return OPVCC(12, 0, 0, 0)
4904         case AADDCCC:
4905                 return OPVCC(13, 0, 0, 0)
4906         case AADDIS:
4907                 return OPVCC(15, 0, 0, 0) /* ADDIS */
4908
4909         case AANDCC:
4910                 return OPVCC(28, 0, 0, 0)
4911         case AANDISCC:
4912                 return OPVCC(29, 0, 0, 0) /* ANDIS. */
4913
4914         case ABR:
4915                 return OPVCC(18, 0, 0, 0)
4916         case ABL:
4917                 return OPVCC(18, 0, 0, 0) | 1
4918         case obj.ADUFFZERO:
4919                 return OPVCC(18, 0, 0, 0) | 1
4920         case obj.ADUFFCOPY:
4921                 return OPVCC(18, 0, 0, 0) | 1
4922         case ABC:
4923                 return OPVCC(16, 0, 0, 0)
4924         case ABCL:
4925                 return OPVCC(16, 0, 0, 0) | 1
4926
4927         case ABEQ:
4928                 return AOP_RRR(16<<26, 12, 2, 0)
4929         case ABGE:
4930                 return AOP_RRR(16<<26, 4, 0, 0)
4931         case ABGT:
4932                 return AOP_RRR(16<<26, 12, 1, 0)
4933         case ABLE:
4934                 return AOP_RRR(16<<26, 4, 1, 0)
4935         case ABLT:
4936                 return AOP_RRR(16<<26, 12, 0, 0)
4937         case ABNE:
4938                 return AOP_RRR(16<<26, 4, 2, 0)
4939         case ABVC:
4940                 return AOP_RRR(16<<26, 4, 3, 0) // apparently unordered-clear
4941         case ABVS:
4942                 return AOP_RRR(16<<26, 12, 3, 0) // apparently unordered-set
4943
4944         case ACMP:
4945                 return OPVCC(11, 0, 0, 0) | 1<<21 /* L=1 */
4946         case ACMPU:
4947                 return OPVCC(10, 0, 0, 0) | 1<<21
4948         case ACMPW:
4949                 return OPVCC(11, 0, 0, 0) /* L=0 */
4950         case ACMPWU:
4951                 return OPVCC(10, 0, 0, 0)
4952         case ACMPEQB:
4953                 return OPVCC(31, 224, 0, 0) /* cmpeqb - v3.00 */
4954
4955         case ALSW:
4956                 return OPVCC(31, 597, 0, 0)
4957
4958         case ACOPY:
4959                 return OPVCC(31, 774, 0, 0) /* copy - v3.00 */
4960         case APASTECC:
4961                 return OPVCC(31, 902, 0, 1) /* paste. - v3.00 */
4962         case ADARN:
4963                 return OPVCC(31, 755, 0, 0) /* darn - v3.00 */
4964
4965         case AMULLW, AMULLD:
4966                 return OPVCC(7, 0, 0, 0) /* mulli works with MULLW or MULLD */
4967
4968         case AOR:
4969                 return OPVCC(24, 0, 0, 0)
4970         case AORIS:
4971                 return OPVCC(25, 0, 0, 0) /* ORIS */
4972
4973         case ARLWMI:
4974                 return OPVCC(20, 0, 0, 0) /* rlwimi */
4975         case ARLWMICC:
4976                 return OPVCC(20, 0, 0, 1)
4977         case ARLDMI:
4978                 return OPVCC(30, 0, 0, 0) | 3<<2 /* rldimi */
4979         case ARLDMICC:
4980                 return OPVCC(30, 0, 0, 1) | 3<<2
4981         case ARLDIMI:
4982                 return OPVCC(30, 0, 0, 0) | 3<<2 /* rldimi */
4983         case ARLDIMICC:
4984                 return OPVCC(30, 0, 0, 1) | 3<<2
4985         case ARLWNM:
4986                 return OPVCC(21, 0, 0, 0) /* rlwinm */
4987         case ARLWNMCC:
4988                 return OPVCC(21, 0, 0, 1)
4989
4990         case ARLDCL:
4991                 return OPVCC(30, 0, 0, 0) /* rldicl */
4992         case ARLDCLCC:
4993                 return OPVCC(30, 0, 0, 1)
4994         case ARLDCR:
4995                 return OPVCC(30, 1, 0, 0) /* rldicr */
4996         case ARLDCRCC:
4997                 return OPVCC(30, 1, 0, 1)
4998         case ARLDC:
4999                 return OPVCC(30, 0, 0, 0) | 2<<2
5000         case ARLDCCC:
5001                 return OPVCC(30, 0, 0, 1) | 2<<2
5002
5003         case ASRAW:
5004                 return OPVCC(31, 824, 0, 0)
5005         case ASRAWCC:
5006                 return OPVCC(31, 824, 0, 1)
5007         case ASRAD:
5008                 return OPVCC(31, (413 << 1), 0, 0)
5009         case ASRADCC:
5010                 return OPVCC(31, (413 << 1), 0, 1)
5011         case AEXTSWSLI:
5012                 return OPVCC(31, 445, 0, 0)
5013         case AEXTSWSLICC:
5014                 return OPVCC(31, 445, 0, 1)
5015
5016         case ASTSW:
5017                 return OPVCC(31, 725, 0, 0)
5018
5019         case ASUBC:
5020                 return OPVCC(8, 0, 0, 0)
5021
5022         case ATW:
5023                 return OPVCC(3, 0, 0, 0)
5024         case ATD:
5025                 return OPVCC(2, 0, 0, 0)
5026
5027         /* Vector (VMX/Altivec) instructions */
5028         /* ISA 2.03 enables these for PPC970. For POWERx processors, these */
5029         /* are enabled starting at POWER6 (ISA 2.05). */
5030         case AVSPLTB:
5031                 return OPVX(4, 524, 0, 0) /* vspltb - v2.03 */
5032         case AVSPLTH:
5033                 return OPVX(4, 588, 0, 0) /* vsplth - v2.03 */
5034         case AVSPLTW:
5035                 return OPVX(4, 652, 0, 0) /* vspltw - v2.03 */
5036
5037         case AVSPLTISB:
5038                 return OPVX(4, 780, 0, 0) /* vspltisb - v2.03 */
5039         case AVSPLTISH:
5040                 return OPVX(4, 844, 0, 0) /* vspltish - v2.03 */
5041         case AVSPLTISW:
5042                 return OPVX(4, 908, 0, 0) /* vspltisw - v2.03 */
5043         /* End of vector instructions */
5044
5045         case AFTDIV:
5046                 return OPVCC(63, 128, 0, 0) /* ftdiv - v2.06 */
5047         case AFTSQRT:
5048                 return OPVCC(63, 160, 0, 0) /* ftsqrt - v2.06 */
5049
5050         case AXOR:
5051                 return OPVCC(26, 0, 0, 0) /* XORIL */
5052         case AXORIS:
5053                 return OPVCC(27, 0, 0, 0) /* XORIS */
5054         }
5055
5056         c.ctxt.Diag("bad opcode i/r or i/r/r %v", a)
5057         return 0
5058 }
5059
5060 /*
5061  * load o(a),d
5062  */
5063 func (c *ctxt9) opload(a obj.As) uint32 {
5064         switch a {
5065         case AMOVD:
5066                 return OPVCC(58, 0, 0, 0) /* ld */
5067         case AMOVDU:
5068                 return OPVCC(58, 0, 0, 1) /* ldu */
5069         case AMOVWZ:
5070                 return OPVCC(32, 0, 0, 0) /* lwz */
5071         case AMOVWZU:
5072                 return OPVCC(33, 0, 0, 0) /* lwzu */
5073         case AMOVW:
5074                 return OPVCC(58, 0, 0, 0) | 1<<1 /* lwa */
5075         case ALXV:
5076                 return OPDQ(61, 1, 0) /* lxv - ISA v3.0 */
5077         case ALXVL:
5078                 return OPVXX1(31, 269, 0) /* lxvl - ISA v3.0 */
5079         case ALXVLL:
5080                 return OPVXX1(31, 301, 0) /* lxvll - ISA v3.0 */
5081         case ALXVX:
5082                 return OPVXX1(31, 268, 0) /* lxvx - ISA v3.0 */
5083
5084                 /* no AMOVWU */
5085         case AMOVB, AMOVBZ:
5086                 return OPVCC(34, 0, 0, 0)
5087                 /* load */
5088
5089         case AMOVBU, AMOVBZU:
5090                 return OPVCC(35, 0, 0, 0)
5091         case AFMOVD:
5092                 return OPVCC(50, 0, 0, 0)
5093         case AFMOVDU:
5094                 return OPVCC(51, 0, 0, 0)
5095         case AFMOVS:
5096                 return OPVCC(48, 0, 0, 0)
5097         case AFMOVSU:
5098                 return OPVCC(49, 0, 0, 0)
5099         case AMOVH:
5100                 return OPVCC(42, 0, 0, 0)
5101         case AMOVHU:
5102                 return OPVCC(43, 0, 0, 0)
5103         case AMOVHZ:
5104                 return OPVCC(40, 0, 0, 0)
5105         case AMOVHZU:
5106                 return OPVCC(41, 0, 0, 0)
5107         case AMOVMW:
5108                 return OPVCC(46, 0, 0, 0) /* lmw */
5109         }
5110
5111         c.ctxt.Diag("bad load opcode %v", a)
5112         return 0
5113 }
5114
5115 /*
5116  * indexed load a(b),d
5117  */
5118 func (c *ctxt9) oploadx(a obj.As) uint32 {
5119         switch a {
5120         case AMOVWZ:
5121                 return OPVCC(31, 23, 0, 0) /* lwzx */
5122         case AMOVWZU:
5123                 return OPVCC(31, 55, 0, 0) /* lwzux */
5124         case AMOVW:
5125                 return OPVCC(31, 341, 0, 0) /* lwax */
5126         case AMOVWU:
5127                 return OPVCC(31, 373, 0, 0) /* lwaux */
5128
5129         case AMOVB, AMOVBZ:
5130                 return OPVCC(31, 87, 0, 0) /* lbzx */
5131
5132         case AMOVBU, AMOVBZU:
5133                 return OPVCC(31, 119, 0, 0) /* lbzux */
5134         case AFMOVD:
5135                 return OPVCC(31, 599, 0, 0) /* lfdx */
5136         case AFMOVDU:
5137                 return OPVCC(31, 631, 0, 0) /*  lfdux */
5138         case AFMOVS:
5139                 return OPVCC(31, 535, 0, 0) /* lfsx */
5140         case AFMOVSU:
5141                 return OPVCC(31, 567, 0, 0) /* lfsux */
5142         case AFMOVSX:
5143                 return OPVCC(31, 855, 0, 0) /* lfiwax - power6, isa 2.05 */
5144         case AFMOVSZ:
5145                 return OPVCC(31, 887, 0, 0) /* lfiwzx - power7, isa 2.06 */
5146         case AMOVH:
5147                 return OPVCC(31, 343, 0, 0) /* lhax */
5148         case AMOVHU:
5149                 return OPVCC(31, 375, 0, 0) /* lhaux */
5150         case AMOVHBR:
5151                 return OPVCC(31, 790, 0, 0) /* lhbrx */
5152         case AMOVWBR:
5153                 return OPVCC(31, 534, 0, 0) /* lwbrx */
5154         case AMOVDBR:
5155                 return OPVCC(31, 532, 0, 0) /* ldbrx */
5156         case AMOVHZ:
5157                 return OPVCC(31, 279, 0, 0) /* lhzx */
5158         case AMOVHZU:
5159                 return OPVCC(31, 311, 0, 0) /* lhzux */
5160         case AECIWX:
5161                 return OPVCC(31, 310, 0, 0) /* eciwx */
5162         case ALBAR:
5163                 return OPVCC(31, 52, 0, 0) /* lbarx */
5164         case ALHAR:
5165                 return OPVCC(31, 116, 0, 0) /* lharx */
5166         case ALWAR:
5167                 return OPVCC(31, 20, 0, 0) /* lwarx */
5168         case ALDAR:
5169                 return OPVCC(31, 84, 0, 0) /* ldarx */
5170         case ALSW:
5171                 return OPVCC(31, 533, 0, 0) /* lswx */
5172         case AMOVD:
5173                 return OPVCC(31, 21, 0, 0) /* ldx */
5174         case AMOVDU:
5175                 return OPVCC(31, 53, 0, 0) /* ldux */
5176         case ALDMX:
5177                 return OPVCC(31, 309, 0, 0) /* ldmx */
5178
5179         /* Vector (VMX/Altivec) instructions */
5180         case ALVEBX:
5181                 return OPVCC(31, 7, 0, 0) /* lvebx - v2.03 */
5182         case ALVEHX:
5183                 return OPVCC(31, 39, 0, 0) /* lvehx - v2.03 */
5184         case ALVEWX:
5185                 return OPVCC(31, 71, 0, 0) /* lvewx - v2.03 */
5186         case ALVX:
5187                 return OPVCC(31, 103, 0, 0) /* lvx - v2.03 */
5188         case ALVXL:
5189                 return OPVCC(31, 359, 0, 0) /* lvxl - v2.03 */
5190         case ALVSL:
5191                 return OPVCC(31, 6, 0, 0) /* lvsl - v2.03 */
5192         case ALVSR:
5193                 return OPVCC(31, 38, 0, 0) /* lvsr - v2.03 */
5194                 /* End of vector instructions */
5195
5196         /* Vector scalar (VSX) instructions */
5197         case ALXVX:
5198                 return OPVXX1(31, 268, 0) /* lxvx - ISA v3.0 */
5199         case ALXVD2X:
5200                 return OPVXX1(31, 844, 0) /* lxvd2x - v2.06 */
5201         case ALXVW4X:
5202                 return OPVXX1(31, 780, 0) /* lxvw4x - v2.06 */
5203         case ALXVH8X:
5204                 return OPVXX1(31, 812, 0) /* lxvh8x - v3.00 */
5205         case ALXVB16X:
5206                 return OPVXX1(31, 876, 0) /* lxvb16x - v3.00 */
5207         case ALXVDSX:
5208                 return OPVXX1(31, 332, 0) /* lxvdsx - v2.06 */
5209         case ALXSDX:
5210                 return OPVXX1(31, 588, 0) /* lxsdx - v2.06 */
5211         case ALXSIWAX:
5212                 return OPVXX1(31, 76, 0) /* lxsiwax - v2.07 */
5213         case ALXSIWZX:
5214                 return OPVXX1(31, 12, 0) /* lxsiwzx - v2.07 */
5215         }
5216
5217         c.ctxt.Diag("bad loadx opcode %v", a)
5218         return 0
5219 }
5220
5221 /*
5222  * store s,o(d)
5223  */
5224 func (c *ctxt9) opstore(a obj.As) uint32 {
5225         switch a {
5226         case AMOVB, AMOVBZ:
5227                 return OPVCC(38, 0, 0, 0) /* stb */
5228
5229         case AMOVBU, AMOVBZU:
5230                 return OPVCC(39, 0, 0, 0) /* stbu */
5231         case AFMOVD:
5232                 return OPVCC(54, 0, 0, 0) /* stfd */
5233         case AFMOVDU:
5234                 return OPVCC(55, 0, 0, 0) /* stfdu */
5235         case AFMOVS:
5236                 return OPVCC(52, 0, 0, 0) /* stfs */
5237         case AFMOVSU:
5238                 return OPVCC(53, 0, 0, 0) /* stfsu */
5239
5240         case AMOVHZ, AMOVH:
5241                 return OPVCC(44, 0, 0, 0) /* sth */
5242
5243         case AMOVHZU, AMOVHU:
5244                 return OPVCC(45, 0, 0, 0) /* sthu */
5245         case AMOVMW:
5246                 return OPVCC(47, 0, 0, 0) /* stmw */
5247         case ASTSW:
5248                 return OPVCC(31, 725, 0, 0) /* stswi */
5249
5250         case AMOVWZ, AMOVW:
5251                 return OPVCC(36, 0, 0, 0) /* stw */
5252
5253         case AMOVWZU, AMOVWU:
5254                 return OPVCC(37, 0, 0, 0) /* stwu */
5255         case AMOVD:
5256                 return OPVCC(62, 0, 0, 0) /* std */
5257         case AMOVDU:
5258                 return OPVCC(62, 0, 0, 1) /* stdu */
5259         case ASTXV:
5260                 return OPDQ(61, 5, 0) /* stxv ISA 3.0 */
5261         case ASTXVL:
5262                 return OPVXX1(31, 397, 0) /* stxvl ISA 3.0 */
5263         case ASTXVLL:
5264                 return OPVXX1(31, 429, 0) /* stxvll ISA 3.0 */
5265         case ASTXVX:
5266                 return OPVXX1(31, 396, 0) /* stxvx - ISA v3.0 */
5267
5268         }
5269
5270         c.ctxt.Diag("unknown store opcode %v", a)
5271         return 0
5272 }
5273
5274 /*
5275  * indexed store s,a(b)
5276  */
5277 func (c *ctxt9) opstorex(a obj.As) uint32 {
5278         switch a {
5279         case AMOVB, AMOVBZ:
5280                 return OPVCC(31, 215, 0, 0) /* stbx */
5281
5282         case AMOVBU, AMOVBZU:
5283                 return OPVCC(31, 247, 0, 0) /* stbux */
5284         case AFMOVD:
5285                 return OPVCC(31, 727, 0, 0) /* stfdx */
5286         case AFMOVDU:
5287                 return OPVCC(31, 759, 0, 0) /* stfdux */
5288         case AFMOVS:
5289                 return OPVCC(31, 663, 0, 0) /* stfsx */
5290         case AFMOVSU:
5291                 return OPVCC(31, 695, 0, 0) /* stfsux */
5292         case AFMOVSX:
5293                 return OPVCC(31, 983, 0, 0) /* stfiwx */
5294
5295         case AMOVHZ, AMOVH:
5296                 return OPVCC(31, 407, 0, 0) /* sthx */
5297         case AMOVHBR:
5298                 return OPVCC(31, 918, 0, 0) /* sthbrx */
5299
5300         case AMOVHZU, AMOVHU:
5301                 return OPVCC(31, 439, 0, 0) /* sthux */
5302
5303         case AMOVWZ, AMOVW:
5304                 return OPVCC(31, 151, 0, 0) /* stwx */
5305
5306         case AMOVWZU, AMOVWU:
5307                 return OPVCC(31, 183, 0, 0) /* stwux */
5308         case ASTSW:
5309                 return OPVCC(31, 661, 0, 0) /* stswx */
5310         case AMOVWBR:
5311                 return OPVCC(31, 662, 0, 0) /* stwbrx */
5312         case AMOVDBR:
5313                 return OPVCC(31, 660, 0, 0) /* stdbrx */
5314         case ASTBCCC:
5315                 return OPVCC(31, 694, 0, 1) /* stbcx. */
5316         case ASTHCCC:
5317                 return OPVCC(31, 726, 0, 1) /* sthcx. */
5318         case ASTWCCC:
5319                 return OPVCC(31, 150, 0, 1) /* stwcx. */
5320         case ASTDCCC:
5321                 return OPVCC(31, 214, 0, 1) /* stwdx. */
5322         case AECOWX:
5323                 return OPVCC(31, 438, 0, 0) /* ecowx */
5324         case AMOVD:
5325                 return OPVCC(31, 149, 0, 0) /* stdx */
5326         case AMOVDU:
5327                 return OPVCC(31, 181, 0, 0) /* stdux */
5328
5329         /* Vector (VMX/Altivec) instructions */
5330         case ASTVEBX:
5331                 return OPVCC(31, 135, 0, 0) /* stvebx - v2.03 */
5332         case ASTVEHX:
5333                 return OPVCC(31, 167, 0, 0) /* stvehx - v2.03 */
5334         case ASTVEWX:
5335                 return OPVCC(31, 199, 0, 0) /* stvewx - v2.03 */
5336         case ASTVX:
5337                 return OPVCC(31, 231, 0, 0) /* stvx - v2.03 */
5338         case ASTVXL:
5339                 return OPVCC(31, 487, 0, 0) /* stvxl - v2.03 */
5340                 /* End of vector instructions */
5341
5342         /* Vector scalar (VSX) instructions */
5343         case ASTXVX:
5344                 return OPVXX1(31, 396, 0) /* stxvx - v3.0 */
5345         case ASTXVD2X:
5346                 return OPVXX1(31, 972, 0) /* stxvd2x - v2.06 */
5347         case ASTXVW4X:
5348                 return OPVXX1(31, 908, 0) /* stxvw4x - v2.06 */
5349         case ASTXVH8X:
5350                 return OPVXX1(31, 940, 0) /* stxvh8x - v3.0 */
5351         case ASTXVB16X:
5352                 return OPVXX1(31, 1004, 0) /* stxvb16x - v3.0 */
5353
5354         case ASTXSDX:
5355                 return OPVXX1(31, 716, 0) /* stxsdx - v2.06 */
5356
5357         case ASTXSIWX:
5358                 return OPVXX1(31, 140, 0) /* stxsiwx - v2.07 */
5359
5360                 /* End of vector scalar instructions */
5361
5362         }
5363
5364         c.ctxt.Diag("unknown storex opcode %v", a)
5365         return 0
5366 }