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

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