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