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

   1 // cmd/9l/optab.c, cmd/9l/asmout.c from Vita Nuova.
   2 //
   3 //      Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
   4 //      Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
   5 //      Portions Copyright © 1997-1999 Vita Nuova Limited
   6 //      Portions Copyright © 2000-2008 Vita Nuova Holdings Limited (www.vitanuova.com)
   7 //      Portions Copyright © 2004,2006 Bruce Ellis
   8 //      Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
   9 //      Revisions Copyright © 2000-2008 Lucent Technologies Inc. and others
  10 //      Portions Copyright © 2009 The Go Authors. All rights reserved.
  11 //
  12 // Permission is hereby granted, free of charge, to any person obtaining a copy
  13 // of this software and associated documentation files (the "Software"), to deal
  14 // in the Software without restriction, including without limitation the rights
  15 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  16 // copies of the Software, and to permit persons to whom the Software is
  17 // furnished to do so, subject to the following conditions:
  18 //
  19 // The above copyright notice and this permission notice shall be included in
  20 // all copies or substantial portions of the Software.
  21 //
  22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  23 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  24 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  25 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  26 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  27 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  28 // THE SOFTWARE.
  29
  30 package ppc64
  31
  32 import (
  33         "cmd/internal/obj"
  34         "cmd/internal/objabi"
  35         "encoding/binary"
  36         "fmt"
  37         "log"
  38         "math"
  39         "sort"
  40 )
  41
  42 // ctxt9 holds state while assembling a single function.
  43 // Each function gets a fresh ctxt9.
  44 // This allows for multiple functions to be safely concurrently assembled.
  45 type ctxt9 struct {
  46         ctxt       *obj.Link
  47         newprog    obj.ProgAlloc
  48         cursym     *obj.LSym
  49         autosize   int32
  50         instoffset int64
  51         pc         int64
  52 }
  53
  54 // Instruction layout.
  55
  56 const (
  57         funcAlign     = 16
  58         funcAlignMask = funcAlign - 1
  59 )
  60
  61 const (
  62         r0iszero = 1
  63 )
  64
  65 type Optab struct {
  66         as    obj.As // Opcode
  67         a1    uint8  // p.From argument (obj.Addr). p is of type obj.Prog.
  68         a2    uint8  // p.Reg argument (int16 Register)
  69         a3    uint8  // p.RestArgs[0]  (obj.AddrPos)
  70         a4    uint8  // p.RestArgs[1]
  71         a5    uint8  // p.RestARgs[2]
  72         a6    uint8  // p.To (obj.Addr)
  73         type_ int8   // cases in asmout below. E.g., 44 = st r,(ra+rb); 45 = ld (ra+rb), r
  74         size  int8   // Text space in bytes to lay operation
  75 }
  76
  77 // optab contains an array to be sliced of accepted operand combinations for an
  78 // instruction. Unused arguments and fields are not explicitly enumerated, and
  79 // should not be listed for clarity. Unused arguments and values should always
  80 // assume the default value for the given type.
  81 //
  82 // optab does not list every valid ppc64 opcode, it enumerates representative
  83 // operand combinations for a class of instruction.  The variable oprange indexes
  84 // all valid ppc64 opcodes.
  85 //
  86 // oprange is initialized to point a slice within optab which contains the valid
  87 // operand combinations for a given instruction.  This is initialized from buildop.
  88 //
  89 // Likewise, each slice of optab is dynamically sorted using the ocmp Sort interface
  90 // to arrange entries to minimize text size of each opcode.
  91 var optab = []Optab{
  92         {as: obj.ATEXT, a1: C_LOREG, a6: C_TEXTSIZE, type_: 0, size: 0},
  93         {as: obj.ATEXT, a1: C_LOREG, a3: C_LCON, a6: C_TEXTSIZE, type_: 0, size: 0},
  94         {as: obj.ATEXT, a1: C_ADDR, a6: C_TEXTSIZE, type_: 0, size: 0},
  95         {as: obj.ATEXT, a1: C_ADDR, a3: C_LCON, a6: C_TEXTSIZE, type_: 0, size: 0},
  96         /* move register */
  97         {as: AADD, a1: C_REG, a2: C_REG, a6: C_REG, type_: 2, size: 4},
  98         {as: AADD, a1: C_REG, a6: C_REG, type_: 2, size: 4},
  99         {as: AADD, a1: C_SCON, a2: C_REG, a6: C_REG, type_: 4, size: 4},
 100         {as: AADD, a1: C_SCON, a6: C_REG, type_: 4, size: 4},
 101         {as: AADD, a1: C_ADDCON, a2: C_REG, a6: C_REG, type_: 4, size: 4},
 102         {as: AADD, a1: C_ADDCON, a6: C_REG, type_: 4, size: 4},
 103         {as: AADD, a1: C_UCON, a2: C_REG, a6: C_REG, type_: 20, size: 4},
 104         {as: AADD, a1: C_UCON, a6: C_REG, type_: 20, size: 4},
 105         {as: AADD, a1: C_ANDCON, a2: C_REG, a6: C_REG, type_: 22, size: 8},
 106         {as: AADD, a1: C_ANDCON, a6: C_REG, type_: 22, size: 8},
 107         {as: AADD, a1: C_LCON, a2: C_REG, a6: C_REG, type_: 22, size: 12},
 108         {as: AADD, a1: C_LCON, a6: C_REG, type_: 22, size: 12},
 109         {as: AADDIS, a1: C_ADDCON, a2: C_REG, a6: C_REG, type_: 20, size: 4},
 110         {as: AADDIS, a1: C_ADDCON, a6: C_REG, type_: 20, size: 4},
 111         {as: AADDC, a1: C_REG, a2: C_REG, a6: C_REG, type_: 2, size: 4},
 112         {as: AADDC, a1: C_REG, a6: C_REG, type_: 2, size: 4},
 113         {as: AADDC, a1: C_ADDCON, a2: C_REG, a6: C_REG, type_: 4, size: 4},
 114         {as: AADDC, a1: C_ADDCON, a6: C_REG, type_: 4, size: 4},
 115         {as: AADDC, a1: C_LCON, a2: C_REG, a6: C_REG, type_: 22, size: 12},
 116         {as: AADDC, a1: C_LCON, a6: C_REG, type_: 22, size: 12},
 117         {as: AAND, a1: C_REG, a2: C_REG, a6: C_REG, type_: 6, size: 4}, /* logical, no literal */
 118         {as: AAND, a1: C_REG, a6: C_REG, type_: 6, size: 4},
 119         {as: AANDCC, a1: C_REG, a2: C_REG, a6: C_REG, type_: 6, size: 4},
 120         {as: AANDCC, a1: C_REG, a6: C_REG, type_: 6, size: 4},
 121         {as: AANDCC, a1: C_ANDCON, a6: C_REG, type_: 58, size: 4},
 122         {as: AANDCC, a1: C_ANDCON, a2: C_REG, a6: C_REG, type_: 58, size: 4},
 123         {as: AANDCC, a1: C_UCON, a6: C_REG, type_: 59, size: 4},
 124         {as: AANDCC, a1: C_UCON, a2: C_REG, a6: C_REG, type_: 59, size: 4},
 125         {as: AANDCC, a1: C_ADDCON, a6: C_REG, type_: 23, size: 8},
 126         {as: AANDCC, a1: C_ADDCON, a2: C_REG, a6: C_REG, type_: 23, size: 8},
 127         {as: AANDCC, a1: C_LCON, a6: C_REG, type_: 23, size: 12},
 128         {as: AANDCC, a1: C_LCON, a2: C_REG, a6: C_REG, type_: 23, size: 12},
 129         {as: AANDISCC, a1: C_ANDCON, a6: C_REG, type_: 59, size: 4},
 130         {as: AANDISCC, a1: C_ANDCON, a2: C_REG, a6: C_REG, type_: 59, size: 4},
 131         {as: AMULLW, a1: C_REG, a2: C_REG, a6: C_REG, type_: 2, size: 4},
 132         {as: AMULLW, a1: C_REG, a6: C_REG, type_: 2, size: 4},
 133         {as: AMULLW, a1: C_ADDCON, a2: C_REG, a6: C_REG, type_: 4, size: 4},
 134         {as: AMULLW, a1: C_ADDCON, a6: C_REG, type_: 4, size: 4},
 135         {as: AMULLW, a1: C_ANDCON, a2: C_REG, a6: C_REG, type_: 4, size: 4},
 136         {as: AMULLW, a1: C_ANDCON, a6: C_REG, type_: 4, size: 4},
 137         {as: AMULLW, a1: C_LCON, a2: C_REG, a6: C_REG, type_: 22, size: 12},
 138         {as: AMULLW, a1: C_LCON, a6: C_REG, type_: 22, size: 12},
 139         {as: ASUBC, a1: C_REG, a2: C_REG, a6: C_REG, type_: 10, size: 4},
 140         {as: ASUBC, a1: C_REG, a6: C_REG, type_: 10, size: 4},
 141         {as: ASUBC, a1: C_REG, a3: C_ADDCON, a6: C_REG, type_: 27, size: 4},
 142         {as: ASUBC, a1: C_REG, a3: C_LCON, a6: C_REG, type_: 28, size: 12},
 143         {as: AOR, a1: C_REG, a2: C_REG, a6: C_REG, type_: 6, size: 4}, /* logical, literal not cc (or/xor) */
 144         {as: AOR, a1: C_REG, a6: C_REG, type_: 6, size: 4},
 145         {as: AOR, a1: C_ANDCON, a6: C_REG, type_: 58, size: 4},
 146         {as: AOR, a1: C_ANDCON, a2: C_REG, a6: C_REG, type_: 58, size: 4},
 147         {as: AOR, a1: C_UCON, a6: C_REG, type_: 59, size: 4},
 148         {as: AOR, a1: C_UCON, a2: C_REG, a6: C_REG, type_: 59, size: 4},
 149         {as: AOR, a1: C_ADDCON, a6: C_REG, type_: 23, size: 8},
 150         {as: AOR, a1: C_ADDCON, a2: C_REG, a6: C_REG, type_: 23, size: 8},
 151         {as: AOR, a1: C_LCON, a6: C_REG, type_: 23, size: 12},
 152         {as: AOR, a1: C_LCON, a2: C_REG, a6: C_REG, type_: 23, size: 12},
 153         {as: AORIS, a1: C_ANDCON, a6: C_REG, type_: 59, size: 4},
 154         {as: AORIS, a1: C_ANDCON, a2: C_REG, a6: C_REG, type_: 59, size: 4},
 155         {as: ADIVW, a1: C_REG, a2: C_REG, a6: C_REG, type_: 2, size: 4}, /* op r1[,r2],r3 */
 156         {as: ADIVW, a1: C_REG, a6: C_REG, type_: 2, size: 4},
 157         {as: ASUB, a1: C_REG, a2: C_REG, a6: C_REG, type_: 10, size: 4}, /* op r2[,r1],r3 */
 158         {as: ASUB, a1: C_REG, a6: C_REG, type_: 10, size: 4},
 159         {as: ASLW, a1: C_REG, a6: C_REG, type_: 6, size: 4},
 160         {as: ASLW, a1: C_REG, a2: C_REG, a6: C_REG, type_: 6, size: 4},
 161         {as: ASLD, a1: C_REG, a6: C_REG, type_: 6, size: 4},
 162         {as: ASLD, a1: C_REG, a2: C_REG, a6: C_REG, type_: 6, size: 4},
 163         {as: ASLD, a1: C_SCON, a2: C_REG, a6: C_REG, type_: 25, size: 4},
 164         {as: ASLD, a1: C_SCON, a6: C_REG, type_: 25, size: 4},
 165         {as: AEXTSWSLI, a1: C_SCON, a6: C_REG, type_: 25, size: 4},
 166         {as: AEXTSWSLI, a1: C_SCON, a2: C_REG, a6: C_REG, type_: 25, size: 4},
 167         {as: ASLW, a1: C_SCON, a2: C_REG, a6: C_REG, type_: 57, size: 4},
 168         {as: ASLW, a1: C_SCON, a6: C_REG, type_: 57, size: 4},
 169         {as: ASRAW, a1: C_REG, a6: C_REG, type_: 6, size: 4},
 170         {as: ASRAW, a1: C_REG, a2: C_REG, a6: C_REG, type_: 6, size: 4},
 171         {as: ASRAW, a1: C_SCON, a2: C_REG, a6: C_REG, type_: 56, size: 4},
 172         {as: ASRAW, a1: C_SCON, a6: C_REG, type_: 56, size: 4},
 173         {as: ASRAD, a1: C_REG, a6: C_REG, type_: 6, size: 4},
 174         {as: ASRAD, a1: C_REG, a2: C_REG, a6: C_REG, type_: 6, size: 4},
 175         {as: ASRAD, a1: C_SCON, a2: C_REG, a6: C_REG, type_: 56, size: 4},
 176         {as: ASRAD, a1: C_SCON, a6: C_REG, type_: 56, size: 4},
 177         {as: ARLWMI, a1: C_SCON, a2: C_REG, a3: C_LCON, a6: C_REG, type_: 62, size: 4},
 178         {as: ARLWMI, a1: C_SCON, a2: C_REG, a3: C_SCON, a4: C_SCON, a6: C_REG, type_: 102, size: 4},
 179         {as: ARLWMI, a1: C_REG, a2: C_REG, a3: C_LCON, a6: C_REG, type_: 63, size: 4},
 180         {as: ARLWMI, a1: C_REG, a2: C_REG, a3: C_SCON, a4: C_SCON, a6: C_REG, type_: 103, size: 4},
 181         {as: ACLRLSLWI, a1: C_SCON, a2: C_REG, a3: C_LCON, a6: C_REG, type_: 62, size: 4},
 182         {as: ARLDMI, a1: C_SCON, a2: C_REG, a3: C_LCON, a6: C_REG, type_: 30, size: 4},
 183         {as: ARLDC, a1: C_SCON, a2: C_REG, a3: C_LCON, a6: C_REG, type_: 29, size: 4},
 184         {as: ARLDCL, a1: C_SCON, a2: C_REG, a3: C_LCON, a6: C_REG, type_: 29, size: 4},
 185         {as: ARLDCL, a1: C_REG, a2: C_REG, a3: C_LCON, a6: C_REG, type_: 14, size: 4},
 186         {as: ARLDICL, a1: C_REG, a2: C_REG, a3: C_LCON, a6: C_REG, type_: 14, size: 4},
 187         {as: ARLDICL, a1: C_SCON, a2: C_REG, a3: C_LCON, a6: C_REG, type_: 14, size: 4},
 188         {as: ARLDCL, a1: C_REG, a3: C_LCON, a6: C_REG, type_: 14, size: 4},
 189         {as: AFADD, a1: C_FREG, a6: C_FREG, type_: 2, size: 4},
 190         {as: AFADD, a1: C_FREG, a2: C_FREG, a6: C_FREG, type_: 2, size: 4},
 191         {as: AFABS, a1: C_FREG, a6: C_FREG, type_: 33, size: 4},
 192         {as: AFABS, a6: C_FREG, type_: 33, size: 4},
 193         {as: AFMADD, a1: C_FREG, a2: C_FREG, a3: C_FREG, a6: C_FREG, type_: 34, size: 4},
 194         {as: AFMUL, a1: C_FREG, a6: C_FREG, type_: 32, size: 4},
 195         {as: AFMUL, a1: C_FREG, a2: C_FREG, a6: C_FREG, type_: 32, size: 4},
 196
 197         {as: AMOVBU, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 198         {as: AMOVBU, a1: C_SOREG, a6: C_REG, type_: 9, size: 8},
 199
 200         {as: AMOVBZU, a1: C_REG, a6: C_SOREG, type_: 7, size: 4},
 201         {as: AMOVBZU, a1: C_SOREG, a6: C_REG, type_: 8, size: 4},
 202
 203         {as: AMOVHBR, a1: C_REG, a6: C_ZOREG, type_: 44, size: 4},
 204         {as: AMOVHBR, a1: C_ZOREG, a6: C_REG, type_: 45, size: 4},
 205
 206         {as: AMOVB, a1: C_ADDR, a6: C_REG, type_: 76, size: 12},
 207         {as: AMOVB, a1: C_LOREG, a6: C_REG, type_: 37, size: 12},
 208         {as: AMOVB, a1: C_SOREG, a6: C_REG, type_: 9, 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) */
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         case 9: /* movb soreg, r ==> lbz o(r),r2; extsb r2,r2 */
2505                 r := int(p.From.Reg)
2506
2507                 if r == 0 {
2508                         r = c.getimpliedreg(&p.From, p)
2509                 }
2510                 v := c.regoff(&p.From)
2511                 if p.From.Type == obj.TYPE_MEM && p.From.Index != 0 {
2512                         if v != 0 {
2513                                 c.ctxt.Diag("illegal indexed instruction\n%v", p)
2514                         }
2515                         o1 = AOP_RRR(c.oploadx(p.As), uint32(p.To.Reg), uint32(p.From.Index), uint32(r))
2516                 } else {
2517                         o1 = AOP_IRR(c.opload(p.As), uint32(p.To.Reg), uint32(r), uint32(v))
2518                 }
2519                 o2 = LOP_RRR(OP_EXTSB, uint32(p.To.Reg), uint32(p.To.Reg), 0)
2520
2521         case 10: /* sub Ra,[Rb],Rd => subf Rd,Ra,Rb */
2522                 r := int(p.Reg)
2523
2524                 if r == 0 {
2525                         r = int(p.To.Reg)
2526                 }
2527                 o1 = AOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), uint32(p.From.Reg), uint32(r))
2528
2529         case 11: /* br/bl lbra */
2530                 v := int32(0)
2531
2532                 if p.To.Target() != nil {
2533                         v = int32(p.To.Target().Pc - p.Pc)
2534                         if v&03 != 0 {
2535                                 c.ctxt.Diag("odd branch target address\n%v", p)
2536                                 v &^= 03
2537                         }
2538
2539                         if v < -(1<<25) || v >= 1<<24 {
2540                                 c.ctxt.Diag("branch too far\n%v", p)
2541                         }
2542                 }
2543
2544                 o1 = OP_BR(c.opirr(p.As), uint32(v), 0)
2545                 if p.To.Sym != nil {
2546                         rel := obj.Addrel(c.cursym)
2547                         rel.Off = int32(c.pc)
2548                         rel.Siz = 4
2549                         rel.Sym = p.To.Sym
2550                         v += int32(p.To.Offset)
2551                         if v&03 != 0 {
2552                                 c.ctxt.Diag("odd branch target address\n%v", p)
2553                                 v &^= 03
2554                         }
2555
2556                         rel.Add = int64(v)
2557                         rel.Type = objabi.R_CALLPOWER
2558                 }
2559                 o2 = 0x60000000 // nop, sometimes overwritten by ld r2, 24(r1) when dynamic linking
2560
2561         case 13: /* mov[bhwd]{z,} r,r */
2562                 // This needs to handle "MOV* $0, Rx".  This shows up because $0 also
2563                 // matches C_REG if r0iszero. This happens because C_REG sorts before C_ANDCON
2564                 // TODO: fix the above behavior and cleanup this exception.
2565                 if p.From.Type == obj.TYPE_CONST {
2566                         o1 = LOP_IRR(OP_ADDI, REGZERO, uint32(p.To.Reg), 0)
2567                         break
2568                 }
2569                 if p.To.Type == obj.TYPE_CONST {
2570                         c.ctxt.Diag("cannot move into constant 0\n%v", p)
2571                 }
2572
2573                 switch p.As {
2574                 case AMOVB:
2575                         o1 = LOP_RRR(OP_EXTSB, uint32(p.To.Reg), uint32(p.From.Reg), 0)
2576                 case AMOVBZ:
2577                         o1 = OP_RLW(OP_RLWINM, uint32(p.To.Reg), uint32(p.From.Reg), 0, 24, 31)
2578                 case AMOVH:
2579                         o1 = LOP_RRR(OP_EXTSH, uint32(p.To.Reg), uint32(p.From.Reg), 0)
2580                 case AMOVHZ:
2581                         o1 = OP_RLW(OP_RLWINM, uint32(p.To.Reg), uint32(p.From.Reg), 0, 16, 31)
2582                 case AMOVW:
2583                         o1 = LOP_RRR(OP_EXTSW, uint32(p.To.Reg), uint32(p.From.Reg), 0)
2584                 case AMOVWZ:
2585                         o1 = OP_RLW(OP_RLDIC, uint32(p.To.Reg), uint32(p.From.Reg), 0, 0, 0) | 1<<5 /* MB=32 */
2586                 case AMOVD:
2587                         o1 = LOP_RRR(OP_OR, uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.From.Reg))
2588                 default:
2589                         c.ctxt.Diag("internal: bad register move/truncation\n%v", p)
2590                 }
2591
2592         case 14: /* rldc[lr] Rb,Rs,$mask,Ra -- left, right give different masks */
2593                 r := int(p.Reg)
2594
2595                 if r == 0 {
2596                         r = int(p.To.Reg)
2597                 }
2598                 d := c.vregoff(p.GetFrom3())
2599                 var a int
2600                 switch p.As {
2601
2602                 // These opcodes expect a mask operand that has to be converted into the
2603                 // appropriate operand.  The way these were defined, not all valid masks are possible.
2604                 // Left here for compatibility in case they were used or generated.
2605                 case ARLDCL, ARLDCLCC:
2606                         var mask [2]uint8
2607                         c.maskgen64(p, mask[:], uint64(d))
2608
2609                         a = int(mask[0]) /* MB */
2610                         if mask[1] != 63 {
2611                                 c.ctxt.Diag("invalid mask for rotate: %x (end != bit 63)\n%v", uint64(d), 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                 case ARLDCR, ARLDCRCC:
2620                         var mask [2]uint8
2621                         c.maskgen64(p, mask[:], uint64(d))
2622
2623                         a = int(mask[1]) /* ME */
2624                         if mask[0] != 0 {
2625                                 c.ctxt.Diag("invalid mask for rotate: %x %x (start != 0)\n%v", uint64(d), mask[0], p)
2626                         }
2627                         o1 = LOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), uint32(r), uint32(p.From.Reg))
2628                         o1 |= (uint32(a) & 31) << 6
2629                         if a&0x20 != 0 {
2630                                 o1 |= 1 << 5 /* mb[5] is top bit */
2631                         }
2632
2633                 // These opcodes use a shift count like the ppc64 asm, no mask conversion done
2634                 case ARLDICR, ARLDICRCC:
2635                         me := int(d)
2636                         sh := c.regoff(&p.From)
2637                         if me < 0 || me > 63 || sh > 63 {
2638                                 c.ctxt.Diag("Invalid me or sh for RLDICR: %x %x\n%v", int(d), sh, p)
2639                         }
2640                         o1 = AOP_RLDIC(c.oprrr(p.As), uint32(p.To.Reg), uint32(r), uint32(sh), uint32(me))
2641
2642                 case ARLDICL, ARLDICLCC, ARLDIC, ARLDICCC:
2643                         mb := int(d)
2644                         sh := c.regoff(&p.From)
2645                         if mb < 0 || mb > 63 || sh > 63 {
2646                                 c.ctxt.Diag("Invalid mb or sh for RLDIC, RLDICL: %x %x\n%v", mb, sh, p)
2647                         }
2648                         o1 = AOP_RLDIC(c.oprrr(p.As), uint32(p.To.Reg), uint32(r), uint32(sh), uint32(mb))
2649
2650                 case ACLRLSLDI:
2651                         // This is an extended mnemonic defined in the ISA section C.8.1
2652                         // clrlsldi ra,rs,b,n --> rldic ra,rs,n,b-n
2653                         // It maps onto RLDIC so is directly generated here based on the operands from
2654                         // the clrlsldi.
2655                         n := int32(d)
2656                         b := c.regoff(&p.From)
2657                         if n > b || b > 63 {
2658                                 c.ctxt.Diag("Invalid n or b for CLRLSLDI: %x %x\n%v", n, b, p)
2659                         }
2660                         o1 = AOP_RLDIC(OP_RLDIC, uint32(p.To.Reg), uint32(r), uint32(n), uint32(b)-uint32(n))
2661
2662                 default:
2663                         c.ctxt.Diag("unexpected op in rldc case\n%v", p)
2664                         a = 0
2665                 }
2666
2667         case 17, /* bc bo,bi,lbra (same for now) */
2668                 16: /* bc bo,bi,sbra */
2669                 a := 0
2670
2671                 r := int(p.Reg)
2672
2673                 if p.From.Type == obj.TYPE_CONST {
2674                         a = int(c.regoff(&p.From))
2675                 } else if p.From.Type == obj.TYPE_REG {
2676                         if r != 0 {
2677                                 c.ctxt.Diag("unexpected register setting for branch with CR: %d\n", r)
2678                         }
2679                         // BI values for the CR
2680                         switch p.From.Reg {
2681                         case REG_CR0:
2682                                 r = BI_CR0
2683                         case REG_CR1:
2684                                 r = BI_CR1
2685                         case REG_CR2:
2686                                 r = BI_CR2
2687                         case REG_CR3:
2688                                 r = BI_CR3
2689                         case REG_CR4:
2690                                 r = BI_CR4
2691                         case REG_CR5:
2692                                 r = BI_CR5
2693                         case REG_CR6:
2694                                 r = BI_CR6
2695                         case REG_CR7:
2696                                 r = BI_CR7
2697                         default:
2698                                 c.ctxt.Diag("unrecognized register: expecting CR\n")
2699                         }
2700                 }
2701                 v := int32(0)
2702                 if p.To.Target() != nil {
2703                         v = int32(p.To.Target().Pc - p.Pc)
2704                 }
2705                 if v&03 != 0 {
2706                         c.ctxt.Diag("odd branch target address\n%v", p)
2707                         v &^= 03
2708                 }
2709
2710                 if v < -(1<<16) || v >= 1<<15 {
2711                         c.ctxt.Diag("branch too far\n%v", p)
2712                 }
2713                 o1 = OP_BC(c.opirr(p.As), uint32(a), uint32(r), uint32(v), 0)
2714
2715         case 15: /* br/bl (r) => mov r,lr; br/bl (lr) */
2716                 var v int32
2717                 if p.As == ABC || p.As == ABCL {
2718                         v = c.regoff(&p.To) & 31
2719                 } else {
2720                         v = 20 /* unconditional */
2721                 }
2722                 o1 = AOP_RRR(OP_MTSPR, uint32(p.To.Reg), 0, 0) | (REG_LR&0x1f)<<16 | ((REG_LR>>5)&0x1f)<<11
2723                 o2 = OPVCC(19, 16, 0, 0)
2724                 if p.As == ABL || p.As == ABCL {
2725                         o2 |= 1
2726                 }
2727                 o2 = OP_BCR(o2, uint32(v), uint32(p.To.Index))
2728
2729         case 18: /* br/bl (lr/ctr); bc/bcl bo,bi,(lr/ctr) */
2730                 var v int32
2731                 var bh uint32 = 0
2732                 if p.As == ABC || p.As == ABCL {
2733                         v = c.regoff(&p.From) & 31
2734                 } else {
2735                         v = 20 /* unconditional */
2736                 }
2737                 r := int(p.Reg)
2738                 if r == 0 {
2739                         r = 0
2740                 }
2741                 switch oclass(&p.To) {
2742                 case C_CTR:
2743                         o1 = OPVCC(19, 528, 0, 0)
2744
2745                 case C_LR:
2746                         o1 = OPVCC(19, 16, 0, 0)
2747
2748                 default:
2749                         c.ctxt.Diag("bad optab entry (18): %d\n%v", p.To.Class, p)
2750                         v = 0
2751                 }
2752
2753                 // Insert optional branch hint for bclr[l]/bcctr[l]
2754                 if p.From3Type() != obj.TYPE_NONE {
2755                         bh = uint32(p.GetFrom3().Offset)
2756                         if bh == 2 || bh > 3 {
2757                                 log.Fatalf("BH must be 0,1,3 for %v", p)
2758                         }
2759                         o1 |= bh << 11
2760                 }
2761
2762                 if p.As == ABL || p.As == ABCL {
2763                         o1 |= 1
2764                 }
2765                 o1 = OP_BCR(o1, uint32(v), uint32(r))
2766
2767         case 19: /* mov $lcon,r ==> cau+or */
2768                 d := c.vregoff(&p.From)
2769                 o1 = loadu32(int(p.To.Reg), d)
2770                 o2 = LOP_IRR(OP_ORI, uint32(p.To.Reg), uint32(p.To.Reg), uint32(int32(d)))
2771
2772         case 20: /* add $ucon,,r | addis $addcon,r,r */
2773                 v := c.regoff(&p.From)
2774
2775                 r := int(p.Reg)
2776                 if r == 0 {
2777                         r = int(p.To.Reg)
2778                 }
2779                 if p.As == AADD && (r0iszero == 0 /*TypeKind(100016)*/ && p.Reg == 0 || r0iszero != 0 /*TypeKind(100016)*/ && p.To.Reg == 0) {
2780                         c.ctxt.Diag("literal operation on R0\n%v", p)
2781                 }
2782                 if p.As == AADDIS {
2783                         o1 = AOP_IRR(c.opirr(p.As), uint32(p.To.Reg), uint32(r), uint32(v))
2784                 } else {
2785                         o1 = AOP_IRR(c.opirr(AADDIS), uint32(p.To.Reg), uint32(r), uint32(v)>>16)
2786                 }
2787
2788         case 22: /* add $lcon/$andcon,r1,r2 ==> oris+ori+add/ori+add */
2789                 if p.To.Reg == REGTMP || p.Reg == REGTMP {
2790                         c.ctxt.Diag("can't synthesize large constant\n%v", p)
2791                 }
2792                 d := c.vregoff(&p.From)
2793                 r := int(p.Reg)
2794                 if r == 0 {
2795                         r = int(p.To.Reg)
2796                 }
2797                 if p.From.Sym != nil {
2798                         c.ctxt.Diag("%v is not supported", p)
2799                 }
2800                 // If operand is ANDCON, generate 2 instructions using
2801                 // ORI for unsigned value; with LCON 3 instructions.
2802                 if o.size == 8 {
2803                         o1 = LOP_IRR(OP_ORI, REGTMP, REGZERO, uint32(int32(d)))
2804                         o2 = AOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), REGTMP, uint32(r))
2805                 } else {
2806                         o1 = loadu32(REGTMP, d)
2807                         o2 = LOP_IRR(OP_ORI, REGTMP, REGTMP, uint32(int32(d)))
2808                         o3 = AOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), REGTMP, uint32(r))
2809                 }
2810
2811         case 23: /* and $lcon/$addcon,r1,r2 ==> oris+ori+and/addi+and */
2812                 if p.To.Reg == REGTMP || p.Reg == REGTMP {
2813                         c.ctxt.Diag("can't synthesize large constant\n%v", p)
2814                 }
2815                 d := c.vregoff(&p.From)
2816                 r := int(p.Reg)
2817                 if r == 0 {
2818                         r = int(p.To.Reg)
2819                 }
2820
2821                 // With ADDCON operand, generate 2 instructions using ADDI for signed value,
2822                 // with LCON operand generate 3 instructions.
2823                 if o.size == 8 {
2824                         o1 = LOP_IRR(OP_ADDI, REGZERO, REGTMP, uint32(int32(d)))
2825                         o2 = LOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), REGTMP, uint32(r))
2826                 } else {
2827                         o1 = loadu32(REGTMP, d)
2828                         o2 = LOP_IRR(OP_ORI, REGTMP, REGTMP, uint32(int32(d)))
2829                         o3 = LOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), REGTMP, uint32(r))
2830                 }
2831                 if p.From.Sym != nil {
2832                         c.ctxt.Diag("%v is not supported", p)
2833                 }
2834
2835         case 24: /* lfd fA,float64(0) -> xxlxor xsA,xsaA,xsaA + fneg for -0 */
2836                 o1 = AOP_XX3I(c.oprrr(AXXLXOR), uint32(p.To.Reg), uint32(p.To.Reg), uint32(p.To.Reg), uint32(0))
2837                 // This is needed for -0.
2838                 if o.size == 8 {
2839                         o2 = AOP_RRR(c.oprrr(AFNEG), uint32(p.To.Reg), 0, uint32(p.To.Reg))
2840                 }
2841
2842         case 25:
2843                 /* sld[.] $sh,rS,rA -> rldicr[.] $sh,rS,mask(0,63-sh),rA; srd[.] -> rldicl */
2844                 v := c.regoff(&p.From)
2845
2846                 if v < 0 {
2847                         v = 0
2848                 } else if v > 63 {
2849                         v = 63
2850                 }
2851                 r := int(p.Reg)
2852                 if r == 0 {
2853                         r = int(p.To.Reg)
2854                 }
2855                 var a int
2856                 op := uint32(0)
2857                 switch p.As {
2858                 case ASLD, ASLDCC:
2859                         a = int(63 - v)
2860                         op = OP_RLDICR
2861
2862                 case ASRD, ASRDCC:
2863                         a = int(v)
2864                         v = 64 - v
2865                         op = OP_RLDICL
2866                 case AROTL:
2867                         a = int(0)
2868                         op = OP_RLDICL
2869                 case AEXTSWSLI:
2870                         a = int(v)
2871                 default:
2872                         c.ctxt.Diag("unexpected op in sldi case\n%v", p)
2873                         a = 0
2874                         o1 = 0
2875                 }
2876
2877                 if p.As == AEXTSWSLI || p.As == AEXTSWSLICC {
2878                         o1 = AOP_EXTSWSLI(OP_EXTSWSLI, uint32(r), uint32(p.To.Reg), uint32(v))
2879
2880                 } else {
2881                         o1 = AOP_RLDIC(op, uint32(p.To.Reg), uint32(r), uint32(v), uint32(a))
2882                 }
2883                 if p.As == ASLDCC || p.As == ASRDCC || p.As == AEXTSWSLICC {
2884                         o1 |= 1 // Set the condition code bit
2885                 }
2886
2887         case 26: /* mov $lsext/auto/oreg,,r2 ==> addis+addi */
2888                 v := c.vregoff(&p.From)
2889                 r := int(p.From.Reg)
2890
2891                 switch p.From.Name {
2892                 case obj.NAME_EXTERN, obj.NAME_STATIC:
2893                         // Load a 32 bit constant, or relocation depending on if a symbol is attached
2894                         o1, o2 = c.symbolAccess(p.From.Sym, v, p.To.Reg, OP_ADDI)
2895                 default:
2896                         if r == 0 {
2897                                 r = c.getimpliedreg(&p.From, p)
2898                         }
2899                         // Add a 32 bit offset to a register.
2900                         o1 = AOP_IRR(OP_ADDIS, REGTMP, uint32(r), uint32(high16adjusted(int32(v))))
2901                         o2 = AOP_IRR(OP_ADDI, uint32(p.To.Reg), REGTMP, uint32(v))
2902                 }
2903
2904         case 27: /* subc ra,$simm,rd => subfic rd,ra,$simm */
2905                 v := c.regoff(p.GetFrom3())
2906
2907                 r := int(p.From.Reg)
2908                 o1 = AOP_IRR(c.opirr(p.As), uint32(p.To.Reg), uint32(r), uint32(v))
2909
2910         case 28: /* subc r1,$lcon,r2 ==> cau+or+subfc */
2911                 if p.To.Reg == REGTMP || p.From.Reg == REGTMP {
2912                         c.ctxt.Diag("can't synthesize large constant\n%v", p)
2913                 }
2914                 v := c.regoff(p.GetFrom3())
2915                 o1 = AOP_IRR(OP_ADDIS, REGTMP, REGZERO, uint32(v)>>16)
2916                 o2 = LOP_IRR(OP_ORI, REGTMP, REGTMP, uint32(v))
2917                 o3 = AOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), uint32(p.From.Reg), REGTMP)
2918                 if p.From.Sym != nil {
2919                         c.ctxt.Diag("%v is not supported", p)
2920                 }
2921
2922         case 29: /* rldic[lr]? $sh,s,$mask,a -- left, right, plain give different masks */
2923                 v := c.regoff(&p.From)
2924
2925                 d := c.vregoff(p.GetFrom3())
2926                 var mask [2]uint8
2927                 c.maskgen64(p, mask[:], uint64(d))
2928                 var a int
2929                 switch p.As {
2930                 case ARLDC, ARLDCCC:
2931                         a = int(mask[0]) /* MB */
2932                         if int32(mask[1]) != (63 - v) {
2933                                 c.ctxt.Diag("invalid mask for shift: %x %x (shift %d)\n%v", uint64(d), mask[1], v, p)
2934                         }
2935
2936                 case ARLDCL, ARLDCLCC:
2937                         a = int(mask[0]) /* MB */
2938                         if mask[1] != 63 {
2939                                 c.ctxt.Diag("invalid mask for shift: %x %s (shift %d)\n%v", uint64(d), mask[1], v, p)
2940                         }
2941
2942                 case ARLDCR, ARLDCRCC:
2943                         a = int(mask[1]) /* ME */
2944                         if mask[0] != 0 {
2945                                 c.ctxt.Diag("invalid mask for shift: %x %x (shift %d)\n%v", uint64(d), mask[0], v, p)
2946                         }
2947
2948                 default:
2949                         c.ctxt.Diag("unexpected op in rldic case\n%v", p)
2950                         a = 0
2951                 }
2952
2953                 o1 = AOP_RRR(c.opirr(p.As), uint32(p.Reg), uint32(p.To.Reg), (uint32(v) & 0x1F))
2954                 o1 |= (uint32(a) & 31) << 6
2955                 if v&0x20 != 0 {
2956                         o1 |= 1 << 1
2957                 }
2958                 if a&0x20 != 0 {
2959                         o1 |= 1 << 5 /* mb[5] is top bit */
2960                 }
2961
2962         case 30: /* rldimi $sh,s,$mask,a */
2963                 v := c.regoff(&p.From)
2964
2965                 d := c.vregoff(p.GetFrom3())
2966
2967                 // Original opcodes had mask operands which had to be converted to a shift count as expected by
2968                 // the ppc64 asm.
2969                 switch p.As {
2970                 case ARLDMI, ARLDMICC:
2971                         var mask [2]uint8
2972                         c.maskgen64(p, mask[:], uint64(d))
2973                         if int32(mask[1]) != (63 - v) {
2974                                 c.ctxt.Diag("invalid mask for shift: %x %x (shift %d)\n%v", uint64(d), mask[1], v, p)
2975                         }
2976                         o1 = AOP_RRR(c.opirr(p.As), uint32(p.Reg), uint32(p.To.Reg), (uint32(v) & 0x1F))
2977                         o1 |= (uint32(mask[0]) & 31) << 6
2978                         if v&0x20 != 0 {
2979                                 o1 |= 1 << 1
2980                         }
2981                         if mask[0]&0x20 != 0 {
2982                                 o1 |= 1 << 5 /* mb[5] is top bit */
2983                         }
2984
2985                 // Opcodes with shift count operands.
2986                 case ARLDIMI, ARLDIMICC:
2987                         o1 = AOP_RRR(c.opirr(p.As), uint32(p.Reg), uint32(p.To.Reg), (uint32(v) & 0x1F))
2988                         o1 |= (uint32(d) & 31) << 6
2989                         if d&0x20 != 0 {
2990                                 o1 |= 1 << 5
2991                         }
2992                         if v&0x20 != 0 {
2993                                 o1 |= 1 << 1
2994                         }
2995                 }
2996
2997         case 31: /* dword */
2998                 d := c.vregoff(&p.From)
2999
3000                 if c.ctxt.Arch.ByteOrder == binary.BigEndian {
3001                         o1 = uint32(d >> 32)
3002                         o2 = uint32(d)
3003                 } else {
3004                         o1 = uint32(d)
3005                         o2 = uint32(d >> 32)
3006                 }
3007
3008                 if p.From.Sym != nil {
3009                         rel := obj.Addrel(c.cursym)
3010                         rel.Off = int32(c.pc)
3011                         rel.Siz = 8
3012                         rel.Sym = p.From.Sym
3013                         rel.Add = p.From.Offset
3014                         rel.Type = objabi.R_ADDR
3015                         o2 = 0
3016                         o1 = o2
3017                 }
3018
3019         case 32: /* fmul frc,fra,frd */
3020                 r := int(p.Reg)
3021
3022                 if r == 0 {
3023                         r = int(p.To.Reg)
3024                 }
3025                 o1 = AOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), uint32(r), 0) | (uint32(p.From.Reg)&31)<<6
3026
3027         case 33: /* fabs [frb,]frd; fmr. frb,frd */
3028                 r := int(p.From.Reg)
3029
3030                 if oclass(&p.From) == C_NONE {
3031                         r = int(p.To.Reg)
3032                 }
3033                 o1 = AOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), 0, uint32(r))
3034
3035         case 34: /* FMADDx fra,frb,frc,frt (t=a*c±b) */
3036                 o1 = AOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.Reg)) | (uint32(p.GetFrom3().Reg)&31)<<6
3037
3038         case 35: /* mov r,lext/lauto/loreg ==> cau $(v>>16),sb,r'; store o(r') */
3039                 v := c.regoff(&p.To)
3040
3041                 r := int(p.To.Reg)
3042                 if r == 0 {
3043                         r = c.getimpliedreg(&p.To, p)
3044                 }
3045                 // Offsets in DS form stores must be a multiple of 4
3046                 inst := c.opstore(p.As)
3047                 if c.opform(inst) == DS_FORM && v&0x3 != 0 {
3048                         log.Fatalf("invalid offset for DS form load/store %v", p)
3049                 }
3050                 o1 = AOP_IRR(OP_ADDIS, REGTMP, uint32(r), uint32(high16adjusted(v)))
3051                 o2 = AOP_IRR(inst, uint32(p.From.Reg), REGTMP, uint32(v))
3052
3053         case 36: /* mov bz/h/hz lext/lauto/lreg,r ==> lbz/lha/lhz etc */
3054                 v := c.regoff(&p.From)
3055
3056                 r := int(p.From.Reg)
3057                 if r == 0 {
3058                         r = c.getimpliedreg(&p.From, p)
3059                 }
3060                 o1 = AOP_IRR(OP_ADDIS, REGTMP, uint32(r), uint32(high16adjusted(v)))
3061                 o2 = AOP_IRR(c.opload(p.As), uint32(p.To.Reg), REGTMP, uint32(v))
3062
3063         case 37: /* movb lext/lauto/lreg,r ==> lbz o(reg),r; extsb r */
3064                 v := c.regoff(&p.From)
3065
3066                 r := int(p.From.Reg)
3067                 if r == 0 {
3068                         r = c.getimpliedreg(&p.From, p)
3069                 }
3070                 o1 = AOP_IRR(OP_ADDIS, REGTMP, uint32(r), uint32(high16adjusted(v)))
3071                 o2 = AOP_IRR(c.opload(p.As), uint32(p.To.Reg), REGTMP, uint32(v))
3072                 o3 = LOP_RRR(OP_EXTSB, uint32(p.To.Reg), uint32(p.To.Reg), 0)
3073
3074         case 40: /* word */
3075                 o1 = uint32(c.regoff(&p.From))
3076
3077         case 41: /* stswi */
3078                 o1 = AOP_RRR(c.opirr(p.As), uint32(p.From.Reg), uint32(p.To.Reg), 0) | (uint32(c.regoff(p.GetFrom3()))&0x7F)<<11
3079
3080         case 42: /* lswi */
3081                 o1 = AOP_RRR(c.opirr(p.As), uint32(p.To.Reg), uint32(p.From.Reg), 0) | (uint32(c.regoff(p.GetFrom3()))&0x7F)<<11
3082
3083         case 43: /* data cache instructions: op (Ra+[Rb]), [th|l] */
3084                 /* TH field for dcbt/dcbtst: */
3085                 /* 0 = Block access - program will soon access EA. */
3086                 /* 8-15 = Stream access - sequence of access (data stream). See section 4.3.2 of the ISA for details. */
3087                 /* 16 = Block access - program will soon make a transient access to EA. */
3088                 /* 17 = Block access - program will not access EA for a long time. */
3089
3090                 /* L field for dcbf: */
3091                 /* 0 = invalidates the block containing EA in all processors. */
3092                 /* 1 = same as 0, but with limited scope (i.e. block in the current processor will not be reused soon). */
3093                 /* 3 = same as 1, but with even more limited scope (i.e. block in the current processor primary cache will not be reused soon). */
3094                 if p.To.Type == obj.TYPE_NONE {
3095                         o1 = AOP_RRR(c.oprrr(p.As), 0, uint32(p.From.Index), uint32(p.From.Reg))
3096                 } else {
3097                         th := c.regoff(&p.To)
3098                         o1 = AOP_RRR(c.oprrr(p.As), uint32(th), uint32(p.From.Index), uint32(p.From.Reg))
3099                 }
3100
3101         case 44: /* indexed store */
3102                 o1 = AOP_RRR(c.opstorex(p.As), uint32(p.From.Reg), uint32(p.To.Index), uint32(p.To.Reg))
3103
3104         case 45: /* indexed load */
3105                 switch p.As {
3106                 /* The assembler accepts a 4-operand l*arx instruction. The fourth operand is an Exclusive Access Hint (EH) */
3107                 /* The EH field can be used as a lock acquire/release hint as follows: */
3108                 /* 0 = Atomic Update (fetch-and-operate or similar algorithm) */
3109                 /* 1 = Exclusive Access (lock acquire and release) */
3110                 case ALBAR, ALHAR, ALWAR, ALDAR:
3111                         if p.From3Type() != obj.TYPE_NONE {
3112                                 eh := int(c.regoff(p.GetFrom3()))
3113                                 if eh > 1 {
3114                                         c.ctxt.Diag("illegal EH field\n%v", p)
3115                                 }
3116                                 o1 = AOP_RRRI(c.oploadx(p.As), uint32(p.To.Reg), uint32(p.From.Index), uint32(p.From.Reg), uint32(eh))
3117                         } else {
3118                                 o1 = AOP_RRR(c.oploadx(p.As), uint32(p.To.Reg), uint32(p.From.Index), uint32(p.From.Reg))
3119                         }
3120                 default:
3121                         o1 = AOP_RRR(c.oploadx(p.As), uint32(p.To.Reg), uint32(p.From.Index), uint32(p.From.Reg))
3122                 }
3123         case 46: /* plain op */
3124                 o1 = c.oprrr(p.As)
3125
3126         case 47: /* op Ra, Rd; also op [Ra,] Rd */
3127                 r := int(p.From.Reg)
3128
3129                 if r == 0 {
3130                         r = int(p.To.Reg)
3131                 }
3132                 o1 = AOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), uint32(r), 0)
3133
3134         case 48: /* op Rs, Ra */
3135                 r := int(p.From.Reg)
3136
3137                 if r == 0 {
3138                         r = int(p.To.Reg)
3139                 }
3140                 o1 = LOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), uint32(r), 0)
3141
3142         case 49: /* op Rb; op $n, Rb */
3143                 if p.From.Type != obj.TYPE_REG { /* tlbie $L, rB */
3144                         v := c.regoff(&p.From) & 1
3145                         o1 = AOP_RRR(c.oprrr(p.As), 0, 0, uint32(p.To.Reg)) | uint32(v)<<21
3146                 } else {
3147                         o1 = AOP_RRR(c.oprrr(p.As), 0, 0, uint32(p.From.Reg))
3148                 }
3149
3150         case 50: /* rem[u] r1[,r2],r3 */
3151                 r := int(p.Reg)
3152
3153                 if r == 0 {
3154                         r = int(p.To.Reg)
3155                 }
3156                 v := c.oprrr(p.As)
3157                 t := v & (1<<10 | 1) /* OE|Rc */
3158                 o1 = AOP_RRR(v&^t, REGTMP, uint32(r), uint32(p.From.Reg))
3159                 o2 = AOP_RRR(OP_MULLW, REGTMP, REGTMP, uint32(p.From.Reg))
3160                 o3 = AOP_RRR(OP_SUBF|t, uint32(p.To.Reg), REGTMP, uint32(r))
3161                 if p.As == AREMU {
3162                         o4 = o3
3163
3164                         /* Clear top 32 bits */
3165                         o3 = OP_RLW(OP_RLDIC, REGTMP, REGTMP, 0, 0, 0) | 1<<5
3166                 }
3167
3168         case 51: /* remd[u] r1[,r2],r3 */
3169                 r := int(p.Reg)
3170
3171                 if r == 0 {
3172                         r = int(p.To.Reg)
3173                 }
3174                 v := c.oprrr(p.As)
3175                 t := v & (1<<10 | 1) /* OE|Rc */
3176                 o1 = AOP_RRR(v&^t, REGTMP, uint32(r), uint32(p.From.Reg))
3177                 o2 = AOP_RRR(OP_MULLD, REGTMP, REGTMP, uint32(p.From.Reg))
3178                 o3 = AOP_RRR(OP_SUBF|t, uint32(p.To.Reg), REGTMP, uint32(r))
3179                 /* cases 50,51: removed; can be reused. */
3180
3181                 /* cases 50,51: removed; can be reused. */
3182
3183         case 52: /* mtfsbNx cr(n) */
3184                 v := c.regoff(&p.From) & 31
3185
3186                 o1 = AOP_RRR(c.oprrr(p.As), uint32(v), 0, 0)
3187
3188         case 53: /* mffsX ,fr1 */
3189                 o1 = AOP_RRR(OP_MFFS, uint32(p.To.Reg), 0, 0)
3190
3191         case 55: /* op Rb, Rd */
3192                 o1 = AOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), 0, uint32(p.From.Reg))
3193
3194         case 56: /* sra $sh,[s,]a; srd $sh,[s,]a */
3195                 v := c.regoff(&p.From)
3196
3197                 r := int(p.Reg)
3198                 if r == 0 {
3199                         r = int(p.To.Reg)
3200                 }
3201                 o1 = AOP_RRR(c.opirr(p.As), uint32(r), uint32(p.To.Reg), uint32(v)&31)
3202                 if (p.As == ASRAD || p.As == ASRADCC) && (v&0x20 != 0) {
3203                         o1 |= 1 << 1 /* mb[5] */
3204                 }
3205
3206         case 57: /* slw $sh,[s,]a -> rlwinm ... */
3207                 v := c.regoff(&p.From)
3208
3209                 r := int(p.Reg)
3210                 if r == 0 {
3211                         r = int(p.To.Reg)
3212                 }
3213
3214                 /*
3215                          * Let user (gs) shoot himself in the foot.
3216                          * qc has already complained.
3217                          *
3218                         if(v < 0 || v > 31)
3219                                 ctxt->diag("illegal shift %ld\n%v", v, p);
3220                 */
3221                 if v < 0 {
3222                         v = 0
3223                 } else if v > 32 {
3224                         v = 32
3225                 }
3226                 var mask [2]uint8
3227                 switch p.As {
3228                 case AROTLW:
3229                         mask[0], mask[1] = 0, 31
3230                 case ASRW, ASRWCC:
3231                         mask[0], mask[1] = uint8(v), 31
3232                         v = 32 - v
3233                 default:
3234                         mask[0], mask[1] = 0, uint8(31-v)
3235                 }
3236                 o1 = OP_RLW(OP_RLWINM, uint32(p.To.Reg), uint32(r), uint32(v), uint32(mask[0]), uint32(mask[1]))
3237                 if p.As == ASLWCC || p.As == ASRWCC {
3238                         o1 |= 1 // set the condition code
3239                 }
3240
3241         case 58: /* logical $andcon,[s],a */
3242                 v := c.regoff(&p.From)
3243
3244                 r := int(p.Reg)
3245                 if r == 0 {
3246                         r = int(p.To.Reg)
3247                 }
3248                 o1 = LOP_IRR(c.opirr(p.As), uint32(p.To.Reg), uint32(r), uint32(v))
3249
3250         case 59: /* or/xor/and $ucon,,r | oris/xoris/andis $addcon,r,r */
3251                 v := c.regoff(&p.From)
3252
3253                 r := int(p.Reg)
3254                 if r == 0 {
3255                         r = int(p.To.Reg)
3256                 }
3257                 switch p.As {
3258                 case AOR:
3259                         o1 = LOP_IRR(c.opirr(AORIS), uint32(p.To.Reg), uint32(r), uint32(v)>>16) /* oris, xoris, andis. */
3260                 case AXOR:
3261                         o1 = LOP_IRR(c.opirr(AXORIS), uint32(p.To.Reg), uint32(r), uint32(v)>>16)
3262                 case AANDCC:
3263                         o1 = LOP_IRR(c.opirr(AANDISCC), uint32(p.To.Reg), uint32(r), uint32(v)>>16)
3264                 default:
3265                         o1 = LOP_IRR(c.opirr(p.As), uint32(p.To.Reg), uint32(r), uint32(v))
3266                 }
3267
3268         case 60: /* tw to,a,b */
3269                 r := int(c.regoff(&p.From) & 31)
3270
3271                 o1 = AOP_RRR(c.oprrr(p.As), uint32(r), uint32(p.Reg), uint32(p.To.Reg))
3272
3273         case 61: /* tw to,a,$simm */
3274                 r := int(c.regoff(&p.From) & 31)
3275
3276                 v := c.regoff(&p.To)
3277                 o1 = AOP_IRR(c.opirr(p.As), uint32(r), uint32(p.Reg), uint32(v))
3278
3279         case 62: /* rlwmi $sh,s,$mask,a */
3280                 v := c.regoff(&p.From)
3281                 switch p.As {
3282                 case ACLRLSLWI:
3283                         n := c.regoff(p.GetFrom3())
3284                         // This is an extended mnemonic described in the ISA C.8.2
3285                         // clrlslwi ra,rs,b,n -> rlwinm ra,rs,n,b-n,31-n
3286                         // It maps onto rlwinm which is directly generated here.
3287                         if n > v || v >= 32 {
3288                                 c.ctxt.Diag("Invalid n or b for CLRLSLWI: %x %x\n%v", v, n, p)
3289                         }
3290
3291                         o1 = OP_RLW(OP_RLWINM, uint32(p.To.Reg), uint32(p.Reg), uint32(n), uint32(v-n), uint32(31-n))
3292                 default:
3293                         var mask [2]uint8
3294                         c.maskgen(p, mask[:], uint32(c.regoff(p.GetFrom3())))
3295                         o1 = AOP_RRR(c.opirr(p.As), uint32(p.Reg), uint32(p.To.Reg), uint32(v))
3296                         o1 |= (uint32(mask[0])&31)<<6 | (uint32(mask[1])&31)<<1
3297                 }
3298
3299         case 63: /* rlwmi b,s,$mask,a */
3300                 var mask [2]uint8
3301                 c.maskgen(p, mask[:], uint32(c.regoff(p.GetFrom3())))
3302                 o1 = AOP_RRR(c.oprrr(p.As), uint32(p.Reg), uint32(p.To.Reg), uint32(p.From.Reg))
3303                 o1 |= (uint32(mask[0])&31)<<6 | (uint32(mask[1])&31)<<1
3304
3305         case 64: /* mtfsf fr[, $m] {,fpcsr} */
3306                 var v int32
3307                 if p.From3Type() != obj.TYPE_NONE {
3308                         v = c.regoff(p.GetFrom3()) & 255
3309                 } else {
3310                         v = 255
3311                 }
3312                 o1 = OP_MTFSF | uint32(v)<<17 | uint32(p.From.Reg)<<11
3313
3314         case 65: /* MOVFL $imm,FPSCR(n) => mtfsfi crfd,imm */
3315                 if p.To.Reg == 0 {
3316                         c.ctxt.Diag("must specify FPSCR(n)\n%v", p)
3317                 }
3318                 o1 = OP_MTFSFI | (uint32(p.To.Reg)&15)<<23 | (uint32(c.regoff(&p.From))&31)<<12
3319
3320         case 66: /* mov spr,r1; mov r1,spr, also dcr */
3321                 var r int
3322                 var v int32
3323                 if REG_R0 <= p.From.Reg && p.From.Reg <= REG_R31 {
3324                         r = int(p.From.Reg)
3325                         v = int32(p.To.Reg)
3326                         if REG_DCR0 <= v && v <= REG_DCR0+1023 {
3327                                 o1 = OPVCC(31, 451, 0, 0) /* mtdcr */
3328                         } else {
3329                                 o1 = OPVCC(31, 467, 0, 0) /* mtspr */
3330                         }
3331                 } else {
3332                         r = int(p.To.Reg)
3333                         v = int32(p.From.Reg)
3334                         if REG_DCR0 <= v && v <= REG_DCR0+1023 {
3335                                 o1 = OPVCC(31, 323, 0, 0) /* mfdcr */
3336                         } else {
3337                                 o1 = OPVCC(31, 339, 0, 0) /* mfspr */
3338                         }
3339                 }
3340
3341                 o1 = AOP_RRR(o1, uint32(r), 0, 0) | (uint32(v)&0x1f)<<16 | ((uint32(v)>>5)&0x1f)<<11
3342
3343         case 67: /* mcrf crfD,crfS */
3344                 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 {
3345                         c.ctxt.Diag("illegal CR field number\n%v", p)
3346                 }
3347                 o1 = AOP_RRR(OP_MCRF, ((uint32(p.To.Reg) & 7) << 2), ((uint32(p.From.Reg) & 7) << 2), 0)
3348
3349         case 68: /* mfcr rD; mfocrf CRM,rD */
3350                 if p.From.Type == obj.TYPE_REG && REG_CR0 <= p.From.Reg && p.From.Reg <= REG_CR7 {
3351                         v := int32(1 << uint(7-(p.To.Reg&7)))                                 /* CR(n) */
3352                         o1 = AOP_RRR(OP_MFCR, uint32(p.To.Reg), 0, 0) | 1<<20 | uint32(v)<<12 /* new form, mfocrf */
3353                 } else {
3354                         o1 = AOP_RRR(OP_MFCR, uint32(p.To.Reg), 0, 0) /* old form, whole register */
3355                 }
3356
3357         case 69: /* mtcrf CRM,rS */
3358                 var v int32
3359                 if p.From3Type() != obj.TYPE_NONE {
3360                         if p.To.Reg != 0 {
3361                                 c.ctxt.Diag("can't use both mask and CR(n)\n%v", p)
3362                         }
3363                         v = c.regoff(p.GetFrom3()) & 0xff
3364                 } else {
3365                         if p.To.Reg == 0 {
3366                                 v = 0xff /* CR */
3367                         } else {
3368                                 v = 1 << uint(7-(p.To.Reg&7)) /* CR(n) */
3369                         }
3370                 }
3371
3372                 o1 = AOP_RRR(OP_MTCRF, uint32(p.From.Reg), 0, 0) | uint32(v)<<12
3373
3374         case 70: /* [f]cmp r,r,cr*/
3375                 var r int
3376                 if p.Reg == 0 {
3377                         r = 0
3378                 } else {
3379                         r = (int(p.Reg) & 7) << 2
3380                 }
3381                 o1 = AOP_RRR(c.oprrr(p.As), uint32(r), uint32(p.From.Reg), uint32(p.To.Reg))
3382
3383         case 71: /* cmp[l] r,i,cr*/
3384                 var r int
3385                 if p.Reg == 0 {
3386                         r = 0
3387                 } else {
3388                         r = (int(p.Reg) & 7) << 2
3389                 }
3390                 o1 = AOP_RRR(c.opirr(p.As), uint32(r), uint32(p.From.Reg), 0) | uint32(c.regoff(&p.To))&0xffff
3391
3392         case 72: /* slbmte (Rb+Rs -> slb[Rb]) -> Rs, Rb */
3393                 o1 = AOP_RRR(c.oprrr(p.As), uint32(p.From.Reg), 0, uint32(p.To.Reg))
3394
3395         case 73: /* mcrfs crfD,crfS */
3396                 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 {
3397                         c.ctxt.Diag("illegal FPSCR/CR field number\n%v", p)
3398                 }
3399                 o1 = AOP_RRR(OP_MCRFS, ((uint32(p.To.Reg) & 7) << 2), ((0 & 7) << 2), 0)
3400
3401         case 77: /* syscall $scon, syscall Rx */
3402                 if p.From.Type == obj.TYPE_CONST {
3403                         if p.From.Offset > BIG || p.From.Offset < -BIG {
3404                                 c.ctxt.Diag("illegal syscall, sysnum too large: %v", p)
3405                         }
3406                         o1 = AOP_IRR(OP_ADDI, REGZERO, REGZERO, uint32(p.From.Offset))
3407                 } else if p.From.Type == obj.TYPE_REG {
3408                         o1 = LOP_RRR(OP_OR, REGZERO, uint32(p.From.Reg), uint32(p.From.Reg))
3409                 } else {
3410                         c.ctxt.Diag("illegal syscall: %v", p)
3411                         o1 = 0x7fe00008 // trap always
3412                 }
3413
3414                 o2 = c.oprrr(p.As)
3415                 o3 = AOP_RRR(c.oprrr(AXOR), REGZERO, REGZERO, REGZERO) // XOR R0, R0
3416
3417         case 78: /* undef */
3418                 o1 = 0 /* "An instruction consisting entirely of binary 0s is guaranteed
3419                    always to be an illegal instruction."  */
3420
3421         /* relocation operations */
3422         case 74:
3423                 v := c.vregoff(&p.To)
3424                 // Offsets in DS form stores must be a multiple of 4
3425                 inst := c.opstore(p.As)
3426                 if c.opform(inst) == DS_FORM && v&0x3 != 0 {
3427                         log.Fatalf("invalid offset for DS form load/store %v", p)
3428                 }
3429                 o1, o2 = c.symbolAccess(p.To.Sym, v, p.From.Reg, inst)
3430
3431         case 75: // 32 bit offset symbol loads (got/toc/addr)
3432                 v := p.From.Offset
3433
3434                 // Offsets in DS form loads must be a multiple of 4
3435                 inst := c.opload(p.As)
3436                 if c.opform(inst) == DS_FORM && v&0x3 != 0 {
3437                         log.Fatalf("invalid offset for DS form load/store %v", p)
3438                 }
3439                 switch p.From.Name {
3440                 case obj.NAME_GOTREF, obj.NAME_TOCREF:
3441                         if v != 0 {
3442                                 c.ctxt.Diag("invalid offset for GOT/TOC access %v", p)
3443                         }
3444                         o1 = AOP_IRR(OP_ADDIS, uint32(p.To.Reg), REG_R2, 0)
3445                         o2 = AOP_IRR(inst, uint32(p.To.Reg), uint32(p.To.Reg), 0)
3446                         rel := obj.Addrel(c.cursym)
3447                         rel.Off = int32(c.pc)
3448                         rel.Siz = 8
3449                         rel.Sym = p.From.Sym
3450                         switch p.From.Name {
3451                         case obj.NAME_GOTREF:
3452                                 rel.Type = objabi.R_ADDRPOWER_GOT
3453                         case obj.NAME_TOCREF:
3454                                 rel.Type = objabi.R_ADDRPOWER_TOCREL_DS
3455                         }
3456                 default:
3457                         o1, o2 = c.symbolAccess(p.From.Sym, v, p.To.Reg, inst)
3458                 }
3459
3460         case 76:
3461                 v := c.vregoff(&p.From)
3462                 // Offsets in DS form loads must be a multiple of 4
3463                 inst := c.opload(p.As)
3464                 if c.opform(inst) == DS_FORM && v&0x3 != 0 {
3465                         log.Fatalf("invalid offset for DS form load/store %v", p)
3466                 }
3467                 o1, o2 = c.symbolAccess(p.From.Sym, v, p.To.Reg, inst)
3468                 o3 = LOP_RRR(OP_EXTSB, uint32(p.To.Reg), uint32(p.To.Reg), 0)
3469
3470         case 79:
3471                 if p.From.Offset != 0 {
3472                         c.ctxt.Diag("invalid offset against tls var %v", p)
3473                 }
3474                 o1 = AOP_IRR(OP_ADDIS, uint32(p.To.Reg), REG_R13, 0)
3475                 o2 = AOP_IRR(OP_ADDI, uint32(p.To.Reg), uint32(p.To.Reg), 0)
3476                 rel := obj.Addrel(c.cursym)
3477                 rel.Off = int32(c.pc)
3478                 rel.Siz = 8
3479                 rel.Sym = p.From.Sym
3480                 rel.Type = objabi.R_POWER_TLS_LE
3481
3482         case 80:
3483                 if p.From.Offset != 0 {
3484                         c.ctxt.Diag("invalid offset against tls var %v", p)
3485                 }
3486                 o1 = AOP_IRR(OP_ADDIS, uint32(p.To.Reg), REG_R2, 0)
3487                 o2 = AOP_IRR(c.opload(AMOVD), uint32(p.To.Reg), uint32(p.To.Reg), 0)
3488                 o3 = AOP_RRR(OP_ADD, uint32(p.To.Reg), uint32(p.To.Reg), REG_R13)
3489                 rel := obj.Addrel(c.cursym)
3490                 rel.Off = int32(c.pc)
3491                 rel.Siz = 8
3492                 rel.Sym = p.From.Sym
3493                 rel.Type = objabi.R_POWER_TLS_IE
3494                 rel = obj.Addrel(c.cursym)
3495                 rel.Off = int32(c.pc) + 8
3496                 rel.Siz = 4
3497                 rel.Sym = p.From.Sym
3498                 rel.Type = objabi.R_POWER_TLS
3499
3500         case 82: /* vector instructions, VX-form and VC-form */
3501                 if p.From.Type == obj.TYPE_REG {
3502                         /* reg reg none OR reg reg reg */
3503                         /* 3-register operand order: VRA, VRB, VRT */
3504                         /* 2-register operand order: VRA, VRT */
3505                         o1 = AOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.Reg))
3506                 } else if p.From3Type() == obj.TYPE_CONST {
3507                         /* imm imm reg reg */
3508                         /* operand order: SIX, VRA, ST, VRT */
3509                         six := int(c.regoff(&p.From))
3510                         st := int(c.regoff(p.GetFrom3()))
3511                         o1 = AOP_IIRR(c.opiirr(p.As), uint32(p.To.Reg), uint32(p.Reg), uint32(st), uint32(six))
3512                 } else if p.From3Type() == obj.TYPE_NONE && p.Reg != 0 {
3513                         /* imm reg reg */
3514                         /* operand order: UIM, VRB, VRT */
3515                         uim := int(c.regoff(&p.From))
3516                         o1 = AOP_VIRR(c.opirr(p.As), uint32(p.To.Reg), uint32(p.Reg), uint32(uim))
3517                 } else {
3518                         /* imm reg */
3519                         /* operand order: SIM, VRT */
3520                         sim := int(c.regoff(&p.From))
3521                         o1 = AOP_IR(c.opirr(p.As), uint32(p.To.Reg), uint32(sim))
3522                 }
3523
3524         case 83: /* vector instructions, VA-form */
3525                 if p.From.Type == obj.TYPE_REG {
3526                         /* reg reg reg reg */
3527                         /* 4-register operand order: VRA, VRB, VRC, VRT */
3528                         o1 = AOP_RRRR(c.oprrr(p.As), uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.Reg), uint32(p.GetFrom3().Reg))
3529                 } else if p.From.Type == obj.TYPE_CONST {
3530                         /* imm reg reg reg */
3531                         /* operand order: SHB, VRA, VRB, VRT */
3532                         shb := int(c.regoff(&p.From))
3533                         o1 = AOP_IRRR(c.opirrr(p.As), uint32(p.To.Reg), uint32(p.Reg), uint32(p.GetFrom3().Reg), uint32(shb))
3534                 }
3535
3536         case 84: // ISEL BC,RA,RB,RT -> isel rt,ra,rb,bc
3537                 bc := c.vregoff(&p.From)
3538
3539                 // rt = To.Reg, ra = p.Reg, rb = p.From3.Reg
3540                 o1 = AOP_ISEL(OP_ISEL, uint32(p.To.Reg), uint32(p.Reg), uint32(p.GetFrom3().Reg), uint32(bc))
3541
3542         case 85: /* vector instructions, VX-form */
3543                 /* reg none reg */
3544                 /* 2-register operand order: VRB, VRT */
3545                 o1 = AOP_RR(c.oprrr(p.As), uint32(p.To.Reg), uint32(p.From.Reg))
3546
3547         case 86: /* VSX indexed store, XX1-form */
3548                 /* reg reg reg */
3549                 /* 3-register operand order: XT, (RB)(RA*1) */
3550                 o1 = AOP_XX1(c.opstorex(p.As), uint32(p.From.Reg), uint32(p.To.Index), uint32(p.To.Reg))
3551
3552         case 87: /* VSX indexed load, XX1-form */
3553                 /* reg reg reg */
3554                 /* 3-register operand order: (RB)(RA*1), XT */
3555                 o1 = AOP_XX1(c.oploadx(p.As), uint32(p.To.Reg), uint32(p.From.Index), uint32(p.From.Reg))
3556
3557         case 88: /* VSX instructions, XX1-form */
3558                 /* reg reg none OR reg reg reg */
3559                 /* 3-register operand order: RA, RB, XT */
3560                 /* 2-register operand order: XS, RA or RA, XT */
3561                 xt := int32(p.To.Reg)
3562                 xs := int32(p.From.Reg)
3563                 /* We need to treat the special case of extended mnemonics that may have a FREG/VREG as an argument */
3564                 if REG_V0 <= xt && xt <= REG_V31 {
3565                         /* Convert V0-V31 to VS32-VS63 */
3566                         xt = xt + 64
3567                         o1 = AOP_XX1(c.oprrr(p.As), uint32(xt), uint32(p.From.Reg), uint32(p.Reg))
3568                 } else if REG_F0 <= xt && xt <= REG_F31 {
3569                         /* Convert F0-F31 to VS0-VS31 */
3570                         xt = xt + 64
3571                         o1 = AOP_XX1(c.oprrr(p.As), uint32(xt), uint32(p.From.Reg), uint32(p.Reg))
3572                 } else if REG_VS0 <= xt && xt <= REG_VS63 {
3573                         o1 = AOP_XX1(c.oprrr(p.As), uint32(xt), uint32(p.From.Reg), uint32(p.Reg))
3574                 } else if REG_V0 <= xs && xs <= REG_V31 {
3575                         /* Likewise for XS */
3576                         xs = xs + 64
3577                         o1 = AOP_XX1(c.oprrr(p.As), uint32(xs), uint32(p.To.Reg), uint32(p.Reg))
3578                 } else if REG_F0 <= xs && xs <= REG_F31 {
3579                         xs = xs + 64
3580                         o1 = AOP_XX1(c.oprrr(p.As), uint32(xs), uint32(p.To.Reg), uint32(p.Reg))
3581                 } else if REG_VS0 <= xs && xs <= REG_VS63 {
3582                         o1 = AOP_XX1(c.oprrr(p.As), uint32(xs), uint32(p.To.Reg), uint32(p.Reg))
3583                 }
3584
3585         case 89: /* VSX instructions, XX2-form */
3586                 /* reg none reg OR reg imm reg */
3587                 /* 2-register operand order: XB, XT or XB, UIM, XT*/
3588                 uim := int(c.regoff(p.GetFrom3()))
3589                 o1 = AOP_XX2(c.oprrr(p.As), uint32(p.To.Reg), uint32(uim), uint32(p.From.Reg))
3590
3591         case 90: /* VSX instructions, XX3-form */
3592                 if p.From3Type() == obj.TYPE_NONE {
3593                         /* reg reg reg */
3594                         /* 3-register operand order: XA, XB, XT */
3595                         o1 = AOP_XX3(c.oprrr(p.As), uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.Reg))
3596                 } else if p.From3Type() == obj.TYPE_CONST {
3597                         /* reg reg reg imm */
3598                         /* operand order: XA, XB, DM, XT */
3599                         dm := int(c.regoff(p.GetFrom3()))
3600                         o1 = AOP_XX3I(c.oprrr(p.As), uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.Reg), uint32(dm))
3601                 }
3602
3603         case 91: /* VSX instructions, XX4-form */
3604                 /* reg reg reg reg */
3605                 /* 3-register operand order: XA, XB, XC, XT */
3606                 o1 = AOP_XX4(c.oprrr(p.As), uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.Reg), uint32(p.GetFrom3().Reg))
3607
3608         case 92: /* X-form instructions, 3-operands */
3609                 if p.To.Type == obj.TYPE_CONST {
3610                         /* imm reg reg */
3611                         xf := int32(p.From.Reg)
3612                         if REG_F0 <= xf && xf <= REG_F31 {
3613                                 /* operand order: FRA, FRB, BF */
3614                                 bf := int(c.regoff(&p.To)) << 2
3615                                 o1 = AOP_RRR(c.opirr(p.As), uint32(bf), uint32(p.From.Reg), uint32(p.Reg))
3616                         } else {
3617                                 /* operand order: RA, RB, L */
3618                                 l := int(c.regoff(&p.To))
3619                                 o1 = AOP_RRR(c.opirr(p.As), uint32(l), uint32(p.From.Reg), uint32(p.Reg))
3620                         }
3621                 } else if p.From3Type() == obj.TYPE_CONST {
3622                         /* reg reg imm */
3623                         /* operand order: RB, L, RA */
3624                         l := int(c.regoff(p.GetFrom3()))
3625                         o1 = AOP_RRR(c.opirr(p.As), uint32(l), uint32(p.To.Reg), uint32(p.From.Reg))
3626                 } else if p.To.Type == obj.TYPE_REG {
3627                         cr := int32(p.To.Reg)
3628                         if REG_CR0 <= cr && cr <= REG_CR7 {
3629                                 /* cr reg reg */
3630                                 /* operand order: RA, RB, BF */
3631                                 bf := (int(p.To.Reg) & 7) << 2
3632                                 o1 = AOP_RRR(c.opirr(p.As), uint32(bf), uint32(p.From.Reg), uint32(p.Reg))
3633                         } else if p.From.Type == obj.TYPE_CONST {
3634                                 /* reg imm */
3635                                 /* operand order: L, RT */
3636                                 l := int(c.regoff(&p.From))
3637                                 o1 = AOP_RRR(c.opirr(p.As), uint32(p.To.Reg), uint32(l), uint32(p.Reg))
3638                         } else {
3639                                 switch p.As {
3640                                 case ACOPY, APASTECC:
3641                                         o1 = AOP_RRR(c.opirr(p.As), uint32(1), uint32(p.From.Reg), uint32(p.To.Reg))
3642                                 default:
3643                                         /* reg reg reg */
3644                                         /* operand order: RS, RB, RA */
3645                                         o1 = AOP_RRR(c.oprrr(p.As), uint32(p.From.Reg), uint32(p.To.Reg), uint32(p.Reg))
3646                                 }
3647                         }
3648                 }
3649
3650         case 93: /* X-form instructions, 2-operands */
3651                 if p.To.Type == obj.TYPE_CONST {
3652                         /* imm reg */
3653                         /* operand order: FRB, BF */
3654                         bf := int(c.regoff(&p.To)) << 2
3655                         o1 = AOP_RR(c.opirr(p.As), uint32(bf), uint32(p.From.Reg))
3656                 } else if p.Reg == 0 {
3657                         /* popcnt* r,r, X-form */
3658                         /* operand order: RS, RA */
3659                         o1 = AOP_RRR(c.oprrr(p.As), uint32(p.From.Reg), uint32(p.To.Reg), uint32(p.Reg))
3660                 }
3661
3662         case 94: /* Z23-form instructions, 4-operands */
3663                 /* reg reg reg imm */
3664                 /* operand order: RA, RB, CY, RT */
3665                 cy := int(c.regoff(p.GetFrom3()))
3666                 o1 = AOP_Z23I(c.oprrr(p.As), uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.Reg), uint32(cy))
3667
3668         case 96: /* VSX load, DQ-form */
3669                 /* reg imm reg */
3670                 /* operand order: (RA)(DQ), XT */
3671                 dq := int16(c.regoff(&p.From))
3672                 if (dq & 15) != 0 {
3673                         c.ctxt.Diag("invalid offset for DQ form load/store %v", dq)
3674                 }
3675                 o1 = AOP_DQ(c.opload(p.As), uint32(p.To.Reg), uint32(p.From.Reg), uint32(dq))
3676
3677         case 97: /* VSX store, DQ-form */
3678                 /* reg imm reg */
3679                 /* operand order: XT, (RA)(DQ) */
3680                 dq := int16(c.regoff(&p.To))
3681                 if (dq & 15) != 0 {
3682                         c.ctxt.Diag("invalid offset for DQ form load/store %v", dq)
3683                 }
3684                 o1 = AOP_DQ(c.opstore(p.As), uint32(p.From.Reg), uint32(p.To.Reg), uint32(dq))
3685         case 98: /* VSX indexed load or load with length (also left-justified), x-form */
3686                 /* vsreg, reg, reg */
3687                 o1 = AOP_XX1(c.opload(p.As), uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.Reg))
3688         case 99: /* VSX store with length (also left-justified) x-form */
3689                 /* reg, reg, vsreg */
3690                 o1 = AOP_XX1(c.opstore(p.As), uint32(p.From.Reg), uint32(p.Reg), uint32(p.To.Reg))
3691         case 100: /* VSX X-form XXSPLTIB */
3692                 if p.From.Type == obj.TYPE_CONST {
3693                         /* imm reg */
3694                         uim := int(c.regoff(&p.From))
3695                         /* imm reg */
3696                         /* Use AOP_XX1 form with 0 for one of the registers. */
3697                         o1 = AOP_XX1(c.oprrr(p.As), uint32(p.To.Reg), uint32(0), uint32(uim))
3698                 } else {
3699                         c.ctxt.Diag("invalid ops for %v", p.As)
3700                 }
3701         case 101:
3702                 o1 = AOP_XX2(c.oprrr(p.As), uint32(p.To.Reg), uint32(0), uint32(p.From.Reg))
3703
3704         case 102: /* RLWMI $sh,rs,$mb,$me,rt (M-form opcode)*/
3705                 mb := uint32(c.regoff(&p.RestArgs[0].Addr))
3706                 me := uint32(c.regoff(&p.RestArgs[1].Addr))
3707                 sh := uint32(c.regoff(&p.From))
3708                 o1 = OP_RLW(c.opirr(p.As), uint32(p.To.Reg), uint32(p.Reg), sh, mb, me)
3709
3710         case 103: /* RLWMI rb,rs,$mb,$me,rt (M-form opcode)*/
3711                 mb := uint32(c.regoff(&p.RestArgs[0].Addr))
3712                 me := uint32(c.regoff(&p.RestArgs[1].Addr))
3713                 o1 = OP_RLW(c.oprrr(p.As), uint32(p.To.Reg), uint32(p.Reg), uint32(p.From.Reg), mb, me)
3714         }
3715
3716         out[0] = o1
3717         out[1] = o2
3718         out[2] = o3
3719         out[3] = o4
3720         out[4] = o5
3721 }
3722
3723 func (c *ctxt9) vregoff(a *obj.Addr) int64 {
3724         c.instoffset = 0
3725         if a != nil {
3726                 c.aclass(a)
3727         }
3728         return c.instoffset
3729 }
3730
3731 func (c *ctxt9) regoff(a *obj.Addr) int32 {
3732         return int32(c.vregoff(a))
3733 }
3734
3735 func (c *ctxt9) oprrr(a obj.As) uint32 {
3736         switch a {
3737         case AADD:
3738                 return OPVCC(31, 266, 0, 0)
3739         case AADDCC:
3740                 return OPVCC(31, 266, 0, 1)
3741         case AADDV:
3742                 return OPVCC(31, 266, 1, 0)
3743         case AADDVCC:
3744                 return OPVCC(31, 266, 1, 1)
3745         case AADDC:
3746                 return OPVCC(31, 10, 0, 0)
3747         case AADDCCC:
3748                 return OPVCC(31, 10, 0, 1)
3749         case AADDCV:
3750                 return OPVCC(31, 10, 1, 0)
3751         case AADDCVCC:
3752                 return OPVCC(31, 10, 1, 1)
3753         case AADDE:
3754                 return OPVCC(31, 138, 0, 0)
3755         case AADDECC:
3756                 return OPVCC(31, 138, 0, 1)
3757         case AADDEV:
3758                 return OPVCC(31, 138, 1, 0)
3759         case AADDEVCC:
3760                 return OPVCC(31, 138, 1, 1)
3761         case AADDME:
3762                 return OPVCC(31, 234, 0, 0)
3763         case AADDMECC:
3764                 return OPVCC(31, 234, 0, 1)
3765         case AADDMEV:
3766                 return OPVCC(31, 234, 1, 0)
3767         case AADDMEVCC:
3768                 return OPVCC(31, 234, 1, 1)
3769         case AADDZE:
3770                 return OPVCC(31, 202, 0, 0)
3771         case AADDZECC:
3772                 return OPVCC(31, 202, 0, 1)
3773         case AADDZEV:
3774                 return OPVCC(31, 202, 1, 0)
3775         case AADDZEVCC:
3776                 return OPVCC(31, 202, 1, 1)
3777         case AADDEX:
3778                 return OPVCC(31, 170, 0, 0) /* addex - v3.0b */
3779
3780         case AAND:
3781                 return OPVCC(31, 28, 0, 0)
3782         case AANDCC:
3783                 return OPVCC(31, 28, 0, 1)
3784         case AANDN:
3785                 return OPVCC(31, 60, 0, 0)
3786         case AANDNCC:
3787                 return OPVCC(31, 60, 0, 1)
3788
3789         case ACMP:
3790                 return OPVCC(31, 0, 0, 0) | 1<<21 /* L=1 */
3791         case ACMPU:
3792                 return OPVCC(31, 32, 0, 0) | 1<<21
3793         case ACMPW:
3794                 return OPVCC(31, 0, 0, 0) /* L=0 */
3795         case ACMPWU:
3796                 return OPVCC(31, 32, 0, 0)
3797         case ACMPB:
3798                 return OPVCC(31, 508, 0, 0) /* cmpb - v2.05 */
3799         case ACMPEQB:
3800                 return OPVCC(31, 224, 0, 0) /* cmpeqb - v3.00 */
3801
3802         case ACNTLZW:
3803                 return OPVCC(31, 26, 0, 0)
3804         case ACNTLZWCC:
3805                 return OPVCC(31, 26, 0, 1)
3806         case ACNTLZD:
3807                 return OPVCC(31, 58, 0, 0)
3808         case ACNTLZDCC:
3809                 return OPVCC(31, 58, 0, 1)
3810
3811         case ACRAND:
3812                 return OPVCC(19, 257, 0, 0)
3813         case ACRANDN:
3814                 return OPVCC(19, 129, 0, 0)
3815         case ACREQV:
3816                 return OPVCC(19, 289, 0, 0)
3817         case ACRNAND:
3818                 return OPVCC(19, 225, 0, 0)
3819         case ACRNOR:
3820                 return OPVCC(19, 33, 0, 0)
3821         case ACROR:
3822                 return OPVCC(19, 449, 0, 0)
3823         case ACRORN:
3824                 return OPVCC(19, 417, 0, 0)
3825         case ACRXOR:
3826                 return OPVCC(19, 193, 0, 0)
3827
3828         case ADCBF:
3829                 return OPVCC(31, 86, 0, 0)
3830         case ADCBI:
3831                 return OPVCC(31, 470, 0, 0)
3832         case ADCBST:
3833                 return OPVCC(31, 54, 0, 0)
3834         case ADCBT:
3835                 return OPVCC(31, 278, 0, 0)
3836         case ADCBTST:
3837                 return OPVCC(31, 246, 0, 0)
3838         case ADCBZ:
3839                 return OPVCC(31, 1014, 0, 0)
3840
3841         case AMODUD:
3842                 return OPVCC(31, 265, 0, 0) /* modud - v3.0 */
3843         case AMODUW:
3844                 return OPVCC(31, 267, 0, 0) /* moduw - v3.0 */
3845         case AMODSD:
3846                 return OPVCC(31, 777, 0, 0) /* modsd - v3.0 */
3847         case AMODSW:
3848                 return OPVCC(31, 779, 0, 0) /* modsw - v3.0 */
3849
3850         case ADIVW, AREM:
3851                 return OPVCC(31, 491, 0, 0)
3852
3853         case ADIVWCC:
3854                 return OPVCC(31, 491, 0, 1)
3855
3856         case ADIVWV:
3857                 return OPVCC(31, 491, 1, 0)
3858
3859         case ADIVWVCC:
3860                 return OPVCC(31, 491, 1, 1)
3861
3862         case ADIVWU, AREMU:
3863                 return OPVCC(31, 459, 0, 0)
3864
3865         case ADIVWUCC:
3866                 return OPVCC(31, 459, 0, 1)
3867
3868         case ADIVWUV:
3869                 return OPVCC(31, 459, 1, 0)
3870
3871         case ADIVWUVCC:
3872                 return OPVCC(31, 459, 1, 1)
3873
3874         case ADIVD, AREMD:
3875                 return OPVCC(31, 489, 0, 0)
3876
3877         case ADIVDCC:
3878                 return OPVCC(31, 489, 0, 1)
3879
3880         case ADIVDE:
3881                 return OPVCC(31, 425, 0, 0)
3882
3883         case ADIVDECC:
3884                 return OPVCC(31, 425, 0, 1)
3885
3886         case ADIVDEU:
3887                 return OPVCC(31, 393, 0, 0)
3888
3889         case ADIVDEUCC:
3890                 return OPVCC(31, 393, 0, 1)
3891
3892         case ADIVDV:
3893                 return OPVCC(31, 489, 1, 0)
3894
3895         case ADIVDVCC:
3896                 return OPVCC(31, 489, 1, 1)
3897
3898         case ADIVDU, AREMDU:
3899                 return OPVCC(31, 457, 0, 0)
3900
3901         case ADIVDUCC:
3902                 return OPVCC(31, 457, 0, 1)
3903
3904         case ADIVDUV:
3905                 return OPVCC(31, 457, 1, 0)
3906
3907         case ADIVDUVCC:
3908                 return OPVCC(31, 457, 1, 1)
3909
3910         case AEIEIO:
3911                 return OPVCC(31, 854, 0, 0)
3912
3913         case AEQV:
3914                 return OPVCC(31, 284, 0, 0)
3915         case AEQVCC:
3916                 return OPVCC(31, 284, 0, 1)
3917
3918         case AEXTSB:
3919                 return OPVCC(31, 954, 0, 0)
3920         case AEXTSBCC:
3921                 return OPVCC(31, 954, 0, 1)
3922         case AEXTSH:
3923                 return OPVCC(31, 922, 0, 0)
3924         case AEXTSHCC:
3925                 return OPVCC(31, 922, 0, 1)
3926         case AEXTSW:
3927                 return OPVCC(31, 986, 0, 0)
3928         case AEXTSWCC:
3929                 return OPVCC(31, 986, 0, 1)
3930
3931         case AFABS:
3932                 return OPVCC(63, 264, 0, 0)
3933         case AFABSCC:
3934                 return OPVCC(63, 264, 0, 1)
3935         case AFADD:
3936                 return OPVCC(63, 21, 0, 0)
3937         case AFADDCC:
3938                 return OPVCC(63, 21, 0, 1)
3939         case AFADDS:
3940                 return OPVCC(59, 21, 0, 0)
3941         case AFADDSCC:
3942                 return OPVCC(59, 21, 0, 1)
3943         case AFCMPO:
3944                 return OPVCC(63, 32, 0, 0)
3945         case AFCMPU:
3946                 return OPVCC(63, 0, 0, 0)
3947         case AFCFID:
3948                 return OPVCC(63, 846, 0, 0)
3949         case AFCFIDCC:
3950                 return OPVCC(63, 846, 0, 1)
3951         case AFCFIDU:
3952                 return OPVCC(63, 974, 0, 0)
3953         case AFCFIDUCC:
3954                 return OPVCC(63, 974, 0, 1)
3955         case AFCFIDS:
3956                 return OPVCC(59, 846, 0, 0)
3957         case AFCFIDSCC:
3958                 return OPVCC(59, 846, 0, 1)
3959         case AFCTIW:
3960                 return OPVCC(63, 14, 0, 0)
3961         case AFCTIWCC:
3962                 return OPVCC(63, 14, 0, 1)
3963         case AFCTIWZ:
3964                 return OPVCC(63, 15, 0, 0)
3965         case AFCTIWZCC:
3966                 return OPVCC(63, 15, 0, 1)
3967         case AFCTID:
3968                 return OPVCC(63, 814, 0, 0)
3969         case AFCTIDCC:
3970                 return OPVCC(63, 814, 0, 1)
3971         case AFCTIDZ:
3972                 return OPVCC(63, 815, 0, 0)
3973         case AFCTIDZCC:
3974                 return OPVCC(63, 815, 0, 1)
3975         case AFDIV:
3976                 return OPVCC(63, 18, 0, 0)
3977         case AFDIVCC:
3978                 return OPVCC(63, 18, 0, 1)
3979         case AFDIVS:
3980                 return OPVCC(59, 18, 0, 0)
3981         case AFDIVSCC:
3982                 return OPVCC(59, 18, 0, 1)
3983         case AFMADD:
3984                 return OPVCC(63, 29, 0, 0)
3985         case AFMADDCC:
3986                 return OPVCC(63, 29, 0, 1)
3987         case AFMADDS:
3988                 return OPVCC(59, 29, 0, 0)
3989         case AFMADDSCC:
3990                 return OPVCC(59, 29, 0, 1)
3991
3992         case AFMOVS, AFMOVD:
3993                 return OPVCC(63, 72, 0, 0) /* load */
3994         case AFMOVDCC:
3995                 return OPVCC(63, 72, 0, 1)
3996         case AFMSUB:
3997                 return OPVCC(63, 28, 0, 0)
3998         case AFMSUBCC:
3999                 return OPVCC(63, 28, 0, 1)
4000         case AFMSUBS:
4001                 return OPVCC(59, 28, 0, 0)
4002         case AFMSUBSCC:
4003                 return OPVCC(59, 28, 0, 1)
4004         case AFMUL:
4005                 return OPVCC(63, 25, 0, 0)
4006         case AFMULCC:
4007                 return OPVCC(63, 25, 0, 1)
4008         case AFMULS:
4009                 return OPVCC(59, 25, 0, 0)
4010         case AFMULSCC:
4011                 return OPVCC(59, 25, 0, 1)
4012         case AFNABS:
4013                 return OPVCC(63, 136, 0, 0)
4014         case AFNABSCC:
4015                 return OPVCC(63, 136, 0, 1)
4016         case AFNEG:
4017                 return OPVCC(63, 40, 0, 0)
4018         case AFNEGCC:
4019                 return OPVCC(63, 40, 0, 1)
4020         case AFNMADD:
4021                 return OPVCC(63, 31, 0, 0)
4022         case AFNMADDCC:
4023                 return OPVCC(63, 31, 0, 1)
4024         case AFNMADDS:
4025                 return OPVCC(59, 31, 0, 0)
4026         case AFNMADDSCC:
4027                 return OPVCC(59, 31, 0, 1)
4028         case AFNMSUB:
4029                 return OPVCC(63, 30, 0, 0)
4030         case AFNMSUBCC:
4031                 return OPVCC(63, 30, 0, 1)
4032         case AFNMSUBS:
4033                 return OPVCC(59, 30, 0, 0)
4034         case AFNMSUBSCC:
4035                 return OPVCC(59, 30, 0, 1)
4036         case AFCPSGN:
4037                 return OPVCC(63, 8, 0, 0)
4038         case AFCPSGNCC:
4039                 return OPVCC(63, 8, 0, 1)
4040         case AFRES:
4041                 return OPVCC(59, 24, 0, 0)
4042         case AFRESCC:
4043                 return OPVCC(59, 24, 0, 1)
4044         case AFRIM:
4045                 return OPVCC(63, 488, 0, 0)
4046         case AFRIMCC:
4047                 return OPVCC(63, 488, 0, 1)
4048         case AFRIP:
4049                 return OPVCC(63, 456, 0, 0)
4050         case AFRIPCC:
4051                 return OPVCC(63, 456, 0, 1)
4052         case AFRIZ:
4053                 return OPVCC(63, 424, 0, 0)
4054         case AFRIZCC:
4055                 return OPVCC(63, 424, 0, 1)
4056         case AFRIN:
4057                 return OPVCC(63, 392, 0, 0)
4058         case AFRINCC:
4059                 return OPVCC(63, 392, 0, 1)
4060         case AFRSP:
4061                 return OPVCC(63, 12, 0, 0)
4062         case AFRSPCC:
4063                 return OPVCC(63, 12, 0, 1)
4064         case AFRSQRTE:
4065                 return OPVCC(63, 26, 0, 0)
4066         case AFRSQRTECC:
4067                 return OPVCC(63, 26, 0, 1)
4068         case AFSEL:
4069                 return OPVCC(63, 23, 0, 0)
4070         case AFSELCC:
4071                 return OPVCC(63, 23, 0, 1)
4072         case AFSQRT:
4073                 return OPVCC(63, 22, 0, 0)
4074         case AFSQRTCC:
4075                 return OPVCC(63, 22, 0, 1)
4076         case AFSQRTS:
4077                 return OPVCC(59, 22, 0, 0)
4078         case AFSQRTSCC:
4079                 return OPVCC(59, 22, 0, 1)
4080         case AFSUB:
4081                 return OPVCC(63, 20, 0, 0)
4082         case AFSUBCC:
4083                 return OPVCC(63, 20, 0, 1)
4084         case AFSUBS:
4085                 return OPVCC(59, 20, 0, 0)
4086         case AFSUBSCC:
4087                 return OPVCC(59, 20, 0, 1)
4088
4089         case AICBI:
4090                 return OPVCC(31, 982, 0, 0)
4091         case AISYNC:
4092                 return OPVCC(19, 150, 0, 0)
4093
4094         case AMTFSB0:
4095                 return OPVCC(63, 70, 0, 0)
4096         case AMTFSB0CC:
4097                 return OPVCC(63, 70, 0, 1)
4098         case AMTFSB1:
4099                 return OPVCC(63, 38, 0, 0)
4100         case AMTFSB1CC:
4101                 return OPVCC(63, 38, 0, 1)
4102
4103         case AMULHW:
4104                 return OPVCC(31, 75, 0, 0)
4105         case AMULHWCC:
4106                 return OPVCC(31, 75, 0, 1)
4107         case AMULHWU:
4108                 return OPVCC(31, 11, 0, 0)
4109         case AMULHWUCC:
4110                 return OPVCC(31, 11, 0, 1)
4111         case AMULLW:
4112                 return OPVCC(31, 235, 0, 0)
4113         case AMULLWCC:
4114                 return OPVCC(31, 235, 0, 1)
4115         case AMULLWV:
4116                 return OPVCC(31, 235, 1, 0)
4117         case AMULLWVCC:
4118                 return OPVCC(31, 235, 1, 1)
4119
4120         case AMULHD:
4121                 return OPVCC(31, 73, 0, 0)
4122         case AMULHDCC:
4123                 return OPVCC(31, 73, 0, 1)
4124         case AMULHDU:
4125                 return OPVCC(31, 9, 0, 0)
4126         case AMULHDUCC:
4127                 return OPVCC(31, 9, 0, 1)
4128         case AMULLD:
4129                 return OPVCC(31, 233, 0, 0)
4130         case AMULLDCC:
4131                 return OPVCC(31, 233, 0, 1)
4132         case AMULLDV:
4133                 return OPVCC(31, 233, 1, 0)
4134         case AMULLDVCC:
4135                 return OPVCC(31, 233, 1, 1)
4136
4137         case ANAND:
4138                 return OPVCC(31, 476, 0, 0)
4139         case ANANDCC:
4140                 return OPVCC(31, 476, 0, 1)
4141         case ANEG:
4142                 return OPVCC(31, 104, 0, 0)
4143         case ANEGCC:
4144                 return OPVCC(31, 104, 0, 1)
4145         case ANEGV:
4146                 return OPVCC(31, 104, 1, 0)
4147         case ANEGVCC:
4148                 return OPVCC(31, 104, 1, 1)
4149         case ANOR:
4150                 return OPVCC(31, 124, 0, 0)
4151         case ANORCC:
4152                 return OPVCC(31, 124, 0, 1)
4153         case AOR:
4154                 return OPVCC(31, 444, 0, 0)
4155         case AORCC:
4156                 return OPVCC(31, 444, 0, 1)
4157         case AORN:
4158                 return OPVCC(31, 412, 0, 0)
4159         case AORNCC:
4160                 return OPVCC(31, 412, 0, 1)
4161
4162         case APOPCNTD:
4163                 return OPVCC(31, 506, 0, 0) /* popcntd - v2.06 */
4164         case APOPCNTW:
4165                 return OPVCC(31, 378, 0, 0) /* popcntw - v2.06 */
4166         case APOPCNTB:
4167                 return OPVCC(31, 122, 0, 0) /* popcntb - v2.02 */
4168         case ACNTTZW:
4169                 return OPVCC(31, 538, 0, 0) /* cnttzw - v3.00 */
4170         case ACNTTZWCC:
4171                 return OPVCC(31, 538, 0, 1) /* cnttzw. - v3.00 */
4172         case ACNTTZD:
4173                 return OPVCC(31, 570, 0, 0) /* cnttzd - v3.00 */
4174         case ACNTTZDCC:
4175                 return OPVCC(31, 570, 0, 1) /* cnttzd. - v3.00 */
4176
4177         case ARFI:
4178                 return OPVCC(19, 50, 0, 0)
4179         case ARFCI:
4180                 return OPVCC(19, 51, 0, 0)
4181         case ARFID:
4182                 return OPVCC(19, 18, 0, 0)
4183         case AHRFID:
4184                 return OPVCC(19, 274, 0, 0)
4185
4186         case ARLWMI:
4187                 return OPVCC(20, 0, 0, 0)
4188         case ARLWMICC:
4189                 return OPVCC(20, 0, 0, 1)
4190         case ARLWNM:
4191                 return OPVCC(23, 0, 0, 0)
4192         case ARLWNMCC:
4193                 return OPVCC(23, 0, 0, 1)
4194
4195         case ARLDCL:
4196                 return OPVCC(30, 8, 0, 0)
4197         case ARLDCLCC:
4198                 return OPVCC(30, 0, 0, 1)
4199
4200         case ARLDCR:
4201                 return OPVCC(30, 9, 0, 0)
4202         case ARLDCRCC:
4203                 return OPVCC(30, 9, 0, 1)
4204
4205         case ARLDICL:
4206                 return OPVCC(30, 0, 0, 0)
4207         case ARLDICLCC:
4208                 return OPVCC(30, 0, 0, 1)
4209         case ARLDICR:
4210                 return OPMD(30, 1, 0) // rldicr
4211         case ARLDICRCC:
4212                 return OPMD(30, 1, 1) // rldicr.
4213
4214         case ARLDIC:
4215                 return OPMD(30, 2, 0) // rldic
4216         case ARLDICCC:
4217                 return OPMD(30, 2, 1) // rldic.
4218
4219         case ASYSCALL:
4220                 return OPVCC(17, 1, 0, 0)
4221
4222         case ASLW:
4223                 return OPVCC(31, 24, 0, 0)
4224         case ASLWCC:
4225                 return OPVCC(31, 24, 0, 1)
4226         case ASLD:
4227                 return OPVCC(31, 27, 0, 0)
4228         case ASLDCC:
4229                 return OPVCC(31, 27, 0, 1)
4230
4231         case ASRAW:
4232                 return OPVCC(31, 792, 0, 0)
4233         case ASRAWCC:
4234                 return OPVCC(31, 792, 0, 1)
4235         case ASRAD:
4236                 return OPVCC(31, 794, 0, 0)
4237         case ASRADCC:
4238                 return OPVCC(31, 794, 0, 1)
4239
4240         case AEXTSWSLI:
4241                 return OPVCC(31, 445, 0, 0)
4242         case AEXTSWSLICC:
4243                 return OPVCC(31, 445, 0, 1)
4244
4245         case ASRW:
4246                 return OPVCC(31, 536, 0, 0)
4247         case ASRWCC:
4248                 return OPVCC(31, 536, 0, 1)
4249         case ASRD:
4250                 return OPVCC(31, 539, 0, 0)
4251         case ASRDCC:
4252                 return OPVCC(31, 539, 0, 1)
4253
4254         case ASUB:
4255                 return OPVCC(31, 40, 0, 0)
4256         case ASUBCC:
4257                 return OPVCC(31, 40, 0, 1)
4258         case ASUBV:
4259                 return OPVCC(31, 40, 1, 0)
4260         case ASUBVCC:
4261                 return OPVCC(31, 40, 1, 1)
4262         case ASUBC:
4263                 return OPVCC(31, 8, 0, 0)
4264         case ASUBCCC:
4265                 return OPVCC(31, 8, 0, 1)
4266         case ASUBCV:
4267                 return OPVCC(31, 8, 1, 0)
4268         case ASUBCVCC:
4269                 return OPVCC(31, 8, 1, 1)
4270         case ASUBE:
4271                 return OPVCC(31, 136, 0, 0)
4272         case ASUBECC:
4273                 return OPVCC(31, 136, 0, 1)
4274         case ASUBEV:
4275                 return OPVCC(31, 136, 1, 0)
4276         case ASUBEVCC:
4277                 return OPVCC(31, 136, 1, 1)
4278         case ASUBME:
4279                 return OPVCC(31, 232, 0, 0)
4280         case ASUBMECC:
4281                 return OPVCC(31, 232, 0, 1)
4282         case ASUBMEV:
4283                 return OPVCC(31, 232, 1, 0)
4284         case ASUBMEVCC:
4285                 return OPVCC(31, 232, 1, 1)
4286         case ASUBZE:
4287                 return OPVCC(31, 200, 0, 0)
4288         case ASUBZECC:
4289                 return OPVCC(31, 200, 0, 1)
4290         case ASUBZEV:
4291                 return OPVCC(31, 200, 1, 0)
4292         case ASUBZEVCC:
4293                 return OPVCC(31, 200, 1, 1)
4294
4295         case ASYNC:
4296                 return OPVCC(31, 598, 0, 0)
4297         case ALWSYNC:
4298                 return OPVCC(31, 598, 0, 0) | 1<<21
4299
4300         case APTESYNC:
4301                 return OPVCC(31, 598, 0, 0) | 2<<21
4302
4303         case ATLBIE:
4304                 return OPVCC(31, 306, 0, 0)
4305         case ATLBIEL:
4306                 return OPVCC(31, 274, 0, 0)
4307         case ATLBSYNC:
4308                 return OPVCC(31, 566, 0, 0)
4309         case ASLBIA:
4310                 return OPVCC(31, 498, 0, 0)
4311         case ASLBIE:
4312                 return OPVCC(31, 434, 0, 0)
4313         case ASLBMFEE:
4314                 return OPVCC(31, 915, 0, 0)
4315         case ASLBMFEV:
4316                 return OPVCC(31, 851, 0, 0)
4317         case ASLBMTE:
4318                 return OPVCC(31, 402, 0, 0)
4319
4320         case ATW:
4321                 return OPVCC(31, 4, 0, 0)
4322         case ATD:
4323                 return OPVCC(31, 68, 0, 0)
4324
4325         /* Vector (VMX/Altivec) instructions */
4326         /* ISA 2.03 enables these for PPC970. For POWERx processors, these */
4327         /* are enabled starting at POWER6 (ISA 2.05). */
4328         case AVAND:
4329                 return OPVX(4, 1028, 0, 0) /* vand - v2.03 */
4330         case AVANDC:
4331                 return OPVX(4, 1092, 0, 0) /* vandc - v2.03 */
4332         case AVNAND:
4333                 return OPVX(4, 1412, 0, 0) /* vnand - v2.07 */
4334
4335         case AVOR:
4336                 return OPVX(4, 1156, 0, 0) /* vor - v2.03 */
4337         case AVORC:
4338                 return OPVX(4, 1348, 0, 0) /* vorc - v2.07 */
4339         case AVNOR:
4340                 return OPVX(4, 1284, 0, 0) /* vnor - v2.03 */
4341         case AVXOR:
4342                 return OPVX(4, 1220, 0, 0) /* vxor - v2.03 */
4343         case AVEQV:
4344                 return OPVX(4, 1668, 0, 0) /* veqv - v2.07 */
4345
4346         case AVADDUBM:
4347                 return OPVX(4, 0, 0, 0) /* vaddubm - v2.03 */
4348         case AVADDUHM:
4349                 return OPVX(4, 64, 0, 0) /* vadduhm - v2.03 */
4350         case AVADDUWM:
4351                 return OPVX(4, 128, 0, 0) /* vadduwm - v2.03 */
4352         case AVADDUDM:
4353                 return OPVX(4, 192, 0, 0) /* vaddudm - v2.07 */
4354         case AVADDUQM:
4355                 return OPVX(4, 256, 0, 0) /* vadduqm - v2.07 */
4356
4357         case AVADDCUQ:
4358                 return OPVX(4, 320, 0, 0) /* vaddcuq - v2.07 */
4359         case AVADDCUW:
4360                 return OPVX(4, 384, 0, 0) /* vaddcuw - v2.03 */
4361
4362         case AVADDUBS:
4363                 return OPVX(4, 512, 0, 0) /* vaddubs - v2.03 */
4364         case AVADDUHS:
4365                 return OPVX(4, 576, 0, 0) /* vadduhs - v2.03 */
4366         case AVADDUWS:
4367                 return OPVX(4, 640, 0, 0) /* vadduws - v2.03 */
4368
4369         case AVADDSBS:
4370                 return OPVX(4, 768, 0, 0) /* vaddsbs - v2.03 */
4371         case AVADDSHS:
4372                 return OPVX(4, 832, 0, 0) /* vaddshs - v2.03 */
4373         case AVADDSWS:
4374                 return OPVX(4, 896, 0, 0) /* vaddsws - v2.03 */
4375
4376         case AVADDEUQM:
4377                 return OPVX(4, 60, 0, 0) /* vaddeuqm - v2.07 */
4378         case AVADDECUQ:
4379                 return OPVX(4, 61, 0, 0) /* vaddecuq - v2.07 */
4380
4381         case AVMULESB:
4382                 return OPVX(4, 776, 0, 0) /* vmulesb - v2.03 */
4383         case AVMULOSB:
4384                 return OPVX(4, 264, 0, 0) /* vmulosb - v2.03 */
4385         case AVMULEUB:
4386                 return OPVX(4, 520, 0, 0) /* vmuleub - v2.03 */
4387         case AVMULOUB:
4388                 return OPVX(4, 8, 0, 0) /* vmuloub - v2.03 */
4389         case AVMULESH:
4390                 return OPVX(4, 840, 0, 0) /* vmulesh - v2.03 */
4391         case AVMULOSH:
4392                 return OPVX(4, 328, 0, 0) /* vmulosh - v2.03 */
4393         case AVMULEUH:
4394                 return OPVX(4, 584, 0, 0) /* vmuleuh - v2.03 */
4395         case AVMULOUH:
4396                 return OPVX(4, 72, 0, 0) /* vmulouh - v2.03 */
4397         case AVMULESW:
4398                 return OPVX(4, 904, 0, 0) /* vmulesw - v2.07 */
4399         case AVMULOSW:
4400                 return OPVX(4, 392, 0, 0) /* vmulosw - v2.07 */
4401         case AVMULEUW:
4402                 return OPVX(4, 648, 0, 0) /* vmuleuw - v2.07 */
4403         case AVMULOUW:
4404                 return OPVX(4, 136, 0, 0) /* vmulouw - v2.07 */
4405         case AVMULUWM:
4406                 return OPVX(4, 137, 0, 0) /* vmuluwm - v2.07 */
4407
4408         case AVPMSUMB:
4409                 return OPVX(4, 1032, 0, 0) /* vpmsumb - v2.07 */
4410         case AVPMSUMH:
4411                 return OPVX(4, 1096, 0, 0) /* vpmsumh - v2.07 */
4412         case AVPMSUMW:
4413                 return OPVX(4, 1160, 0, 0) /* vpmsumw - v2.07 */
4414         case AVPMSUMD:
4415                 return OPVX(4, 1224, 0, 0) /* vpmsumd - v2.07 */
4416
4417         case AVMSUMUDM:
4418                 return OPVX(4, 35, 0, 0) /* vmsumudm - v3.00b */
4419
4420         case AVSUBUBM:
4421                 return OPVX(4, 1024, 0, 0) /* vsububm - v2.03 */
4422         case AVSUBUHM:
4423                 return OPVX(4, 1088, 0, 0) /* vsubuhm - v2.03 */
4424         case AVSUBUWM:
4425                 return OPVX(4, 1152, 0, 0) /* vsubuwm - v2.03 */
4426         case AVSUBUDM:
4427                 return OPVX(4, 1216, 0, 0) /* vsubudm - v2.07 */
4428         case AVSUBUQM:
4429                 return OPVX(4, 1280, 0, 0) /* vsubuqm - v2.07 */
4430
4431         case AVSUBCUQ:
4432                 return OPVX(4, 1344, 0, 0) /* vsubcuq - v2.07 */
4433         case AVSUBCUW:
4434                 return OPVX(4, 1408, 0, 0) /* vsubcuw - v2.03 */
4435
4436         case AVSUBUBS:
4437                 return OPVX(4, 1536, 0, 0) /* vsububs - v2.03 */
4438         case AVSUBUHS:
4439                 return OPVX(4, 1600, 0, 0) /* vsubuhs - v2.03 */
4440         case AVSUBUWS:
4441                 return OPVX(4, 1664, 0, 0) /* vsubuws - v2.03 */
4442
4443         case AVSUBSBS:
4444                 return OPVX(4, 1792, 0, 0) /* vsubsbs - v2.03 */
4445         case AVSUBSHS:
4446                 return OPVX(4, 1856, 0, 0) /* vsubshs - v2.03 */
4447         case AVSUBSWS:
4448                 return OPVX(4, 1920, 0, 0) /* vsubsws - v2.03 */
4449
4450         case AVSUBEUQM:
4451                 return OPVX(4, 62, 0, 0) /* vsubeuqm - v2.07 */
4452         case AVSUBECUQ:
4453                 return OPVX(4, 63, 0, 0) /* vsubecuq - v2.07 */
4454
4455         case AVRLB:
4456                 return OPVX(4, 4, 0, 0) /* vrlb - v2.03 */
4457         case AVRLH:
4458                 return OPVX(4, 68, 0, 0) /* vrlh - v2.03 */
4459         case AVRLW:
4460                 return OPVX(4, 132, 0, 0) /* vrlw - v2.03 */
4461         case AVRLD:
4462                 return OPVX(4, 196, 0, 0) /* vrld - v2.07 */
4463
4464         case AVMRGOW:
4465                 return OPVX(4, 1676, 0, 0) /* vmrgow - v2.07 */
4466         case AVMRGEW:
4467                 return OPVX(4, 1932, 0, 0) /* vmrgew - v2.07 */
4468
4469         case AVSLB:
4470                 return OPVX(4, 260, 0, 0) /* vslh - v2.03 */
4471         case AVSLH:
4472                 return OPVX(4, 324, 0, 0) /* vslh - v2.03 */
4473         case AVSLW:
4474                 return OPVX(4, 388, 0, 0) /* vslw - v2.03 */
4475         case AVSL:
4476                 return OPVX(4, 452, 0, 0) /* vsl - v2.03 */
4477         case AVSLO:
4478                 return OPVX(4, 1036, 0, 0) /* vsl - v2.03 */
4479         case AVSRB:
4480                 return OPVX(4, 516, 0, 0) /* vsrb - v2.03 */
4481         case AVSRH:
4482                 return OPVX(4, 580, 0, 0) /* vsrh - v2.03 */
4483         case AVSRW:
4484                 return OPVX(4, 644, 0, 0) /* vsrw - v2.03 */
4485         case AVSR:
4486                 return OPVX(4, 708, 0, 0) /* vsr - v2.03 */
4487         case AVSRO:
4488                 return OPVX(4, 1100, 0, 0) /* vsro - v2.03 */
4489         case AVSLD:
4490                 return OPVX(4, 1476, 0, 0) /* vsld - v2.07 */
4491         case AVSRD:
4492                 return OPVX(4, 1732, 0, 0) /* vsrd - v2.07 */
4493
4494         case AVSRAB:
4495                 return OPVX(4, 772, 0, 0) /* vsrab - v2.03 */
4496         case AVSRAH:
4497                 return OPVX(4, 836, 0, 0) /* vsrah - v2.03 */
4498         case AVSRAW:
4499                 return OPVX(4, 900, 0, 0) /* vsraw - v2.03 */
4500         case AVSRAD:
4501                 return OPVX(4, 964, 0, 0) /* vsrad - v2.07 */
4502
4503         case AVBPERMQ:
4504                 return OPVC(4, 1356, 0, 0) /* vbpermq - v2.07 */
4505         case AVBPERMD:
4506                 return OPVC(4, 1484, 0, 0) /* vbpermd - v3.00 */
4507
4508         case AVCLZB:
4509                 return OPVX(4, 1794, 0, 0) /* vclzb - v2.07 */
4510         case AVCLZH:
4511                 return OPVX(4, 1858, 0, 0) /* vclzh - v2.07 */
4512         case AVCLZW:
4513                 return OPVX(4, 1922, 0, 0) /* vclzw - v2.07 */
4514         case AVCLZD:
4515                 return OPVX(4, 1986, 0, 0) /* vclzd - v2.07 */
4516
4517         case AVPOPCNTB:
4518                 return OPVX(4, 1795, 0, 0) /* vpopcntb - v2.07 */
4519         case AVPOPCNTH:
4520                 return OPVX(4, 1859, 0, 0) /* vpopcnth - v2.07 */
4521         case AVPOPCNTW:
4522                 return OPVX(4, 1923, 0, 0) /* vpopcntw - v2.07 */
4523         case AVPOPCNTD:
4524                 return OPVX(4, 1987, 0, 0) /* vpopcntd - v2.07 */
4525
4526         case AVCMPEQUB:
4527                 return OPVC(4, 6, 0, 0) /* vcmpequb - v2.03 */
4528         case AVCMPEQUBCC:
4529                 return OPVC(4, 6, 0, 1) /* vcmpequb. - v2.03 */
4530         case AVCMPEQUH:
4531                 return OPVC(4, 70, 0, 0) /* vcmpequh - v2.03 */
4532         case AVCMPEQUHCC:
4533                 return OPVC(4, 70, 0, 1) /* vcmpequh. - v2.03 */
4534         case AVCMPEQUW:
4535                 return OPVC(4, 134, 0, 0) /* vcmpequw - v2.03 */
4536         case AVCMPEQUWCC:
4537                 return OPVC(4, 134, 0, 1) /* vcmpequw. - v2.03 */
4538         case AVCMPEQUD:
4539                 return OPVC(4, 199, 0, 0) /* vcmpequd - v2.07 */
4540         case AVCMPEQUDCC:
4541                 return OPVC(4, 199, 0, 1) /* vcmpequd. - v2.07 */
4542
4543         case AVCMPGTUB:
4544                 return OPVC(4, 518, 0, 0) /* vcmpgtub - v2.03 */
4545         case AVCMPGTUBCC:
4546                 return OPVC(4, 518, 0, 1) /* vcmpgtub. - v2.03 */
4547         case AVCMPGTUH:
4548                 return OPVC(4, 582, 0, 0) /* vcmpgtuh - v2.03 */
4549         case AVCMPGTUHCC:
4550                 return OPVC(4, 582, 0, 1) /* vcmpgtuh. - v2.03 */
4551         case AVCMPGTUW:
4552                 return OPVC(4, 646, 0, 0) /* vcmpgtuw - v2.03 */
4553         case AVCMPGTUWCC:
4554                 return OPVC(4, 646, 0, 1) /* vcmpgtuw. - v2.03 */
4555         case AVCMPGTUD:
4556                 return OPVC(4, 711, 0, 0) /* vcmpgtud - v2.07 */
4557         case AVCMPGTUDCC:
4558                 return OPVC(4, 711, 0, 1) /* vcmpgtud. v2.07 */
4559         case AVCMPGTSB:
4560                 return OPVC(4, 774, 0, 0) /* vcmpgtsb - v2.03 */
4561         case AVCMPGTSBCC:
4562                 return OPVC(4, 774, 0, 1) /* vcmpgtsb. - v2.03 */
4563         case AVCMPGTSH:
4564                 return OPVC(4, 838, 0, 0) /* vcmpgtsh - v2.03 */
4565         case AVCMPGTSHCC:
4566                 return OPVC(4, 838, 0, 1) /* vcmpgtsh. - v2.03 */
4567         case AVCMPGTSW:
4568                 return OPVC(4, 902, 0, 0) /* vcmpgtsw - v2.03 */
4569         case AVCMPGTSWCC:
4570                 return OPVC(4, 902, 0, 1) /* vcmpgtsw. - v2.03 */
4571         case AVCMPGTSD:
4572                 return OPVC(4, 967, 0, 0) /* vcmpgtsd - v2.07 */
4573         case AVCMPGTSDCC:
4574                 return OPVC(4, 967, 0, 1) /* vcmpgtsd. - v2.07 */
4575
4576         case AVCMPNEZB:
4577                 return OPVC(4, 263, 0, 0) /* vcmpnezb - v3.00 */
4578         case AVCMPNEZBCC:
4579                 return OPVC(4, 263, 0, 1) /* vcmpnezb. - v3.00 */
4580         case AVCMPNEB:
4581                 return OPVC(4, 7, 0, 0) /* vcmpneb - v3.00 */
4582         case AVCMPNEBCC:
4583                 return OPVC(4, 7, 0, 1) /* vcmpneb. - v3.00 */
4584         case AVCMPNEH:
4585                 return OPVC(4, 71, 0, 0) /* vcmpneh - v3.00 */
4586         case AVCMPNEHCC:
4587                 return OPVC(4, 71, 0, 1) /* vcmpneh. - v3.00 */
4588         case AVCMPNEW:
4589                 return OPVC(4, 135, 0, 0) /* vcmpnew - v3.00 */
4590         case AVCMPNEWCC:
4591                 return OPVC(4, 135, 0, 1) /* vcmpnew. - v3.00 */
4592
4593         case AVPERM:
4594                 return OPVX(4, 43, 0, 0) /* vperm - v2.03 */
4595         case AVPERMXOR:
4596                 return OPVX(4, 45, 0, 0) /* vpermxor - v2.03 */
4597         case AVPERMR:
4598                 return OPVX(4, 59, 0, 0) /* vpermr - v3.0 */
4599
4600         case AVSEL:
4601                 return OPVX(4, 42, 0, 0) /* vsel - v2.03 */
4602
4603         case AVCIPHER:
4604                 return OPVX(4, 1288, 0, 0) /* vcipher - v2.07 */
4605         case AVCIPHERLAST:
4606                 return OPVX(4, 1289, 0, 0) /* vcipherlast - v2.07 */
4607         case AVNCIPHER:
4608                 return OPVX(4, 1352, 0, 0) /* vncipher - v2.07 */
4609         case AVNCIPHERLAST:
4610                 return OPVX(4, 1353, 0, 0) /* vncipherlast - v2.07 */
4611         case AVSBOX:
4612                 return OPVX(4, 1480, 0, 0) /* vsbox - v2.07 */
4613         /* End of vector instructions */
4614
4615         /* Vector scalar (VSX) instructions */
4616         /* ISA 2.06 enables these for POWER7. */
4617         case AMFVSRD, AMFVRD, AMFFPRD:
4618                 return OPVXX1(31, 51, 0) /* mfvsrd - v2.07 */
4619         case AMFVSRWZ:
4620                 return OPVXX1(31, 115, 0) /* mfvsrwz - v2.07 */
4621         case AMFVSRLD:
4622                 return OPVXX1(31, 307, 0) /* mfvsrld - v3.00 */
4623
4624         case AMTVSRD, AMTFPRD, AMTVRD:
4625                 return OPVXX1(31, 179, 0) /* mtvsrd - v2.07 */
4626         case AMTVSRWA:
4627                 return OPVXX1(31, 211, 0) /* mtvsrwa - v2.07 */
4628         case AMTVSRWZ:
4629                 return OPVXX1(31, 243, 0) /* mtvsrwz - v2.07 */
4630         case AMTVSRDD:
4631                 return OPVXX1(31, 435, 0) /* mtvsrdd - v3.00 */
4632         case AMTVSRWS:
4633                 return OPVXX1(31, 403, 0) /* mtvsrws - v3.00 */
4634
4635         case AXXLAND:
4636                 return OPVXX3(60, 130, 0) /* xxland - v2.06 */
4637         case AXXLANDC:
4638                 return OPVXX3(60, 138, 0) /* xxlandc - v2.06 */
4639         case AXXLEQV:
4640                 return OPVXX3(60, 186, 0) /* xxleqv - v2.07 */
4641         case AXXLNAND:
4642                 return OPVXX3(60, 178, 0) /* xxlnand - v2.07 */
4643
4644         case AXXLORC:
4645                 return OPVXX3(60, 170, 0) /* xxlorc - v2.07 */
4646         case AXXLNOR:
4647                 return OPVXX3(60, 162, 0) /* xxlnor - v2.06 */
4648         case AXXLOR, AXXLORQ:
4649                 return OPVXX3(60, 146, 0) /* xxlor - v2.06 */
4650         case AXXLXOR:
4651                 return OPVXX3(60, 154, 0) /* xxlxor - v2.06 */
4652
4653         case AXXSEL:
4654                 return OPVXX4(60, 3, 0) /* xxsel - v2.06 */
4655
4656         case AXXMRGHW:
4657                 return OPVXX3(60, 18, 0) /* xxmrghw - v2.06 */
4658         case AXXMRGLW:
4659                 return OPVXX3(60, 50, 0) /* xxmrglw - v2.06 */
4660
4661         case AXXSPLTW:
4662                 return OPVXX2(60, 164, 0) /* xxspltw - v2.06 */
4663
4664         case AXXSPLTIB:
4665                 return OPVCC(60, 360, 0, 0) /* xxspltib - v3.0 */
4666
4667         case AXXPERM:
4668                 return OPVXX3(60, 26, 0) /* xxperm - v2.06 */
4669         case AXXPERMDI:
4670                 return OPVXX3(60, 10, 0) /* xxpermdi - v2.06 */
4671
4672         case AXXSLDWI:
4673                 return OPVXX3(60, 2, 0) /* xxsldwi - v2.06 */
4674
4675         case AXXBRQ:
4676                 return OPVXX2VA(60, 475, 31) /* xxbrq - v3.0 */
4677         case AXXBRD:
4678                 return OPVXX2VA(60, 475, 23) /* xxbrd - v3.0 */
4679         case AXXBRW:
4680                 return OPVXX2VA(60, 475, 15) /* xxbrw - v3.0 */
4681         case AXXBRH:
4682                 return OPVXX2VA(60, 475, 7) /* xxbrh - v3.0 */
4683
4684         case AXSCVDPSP:
4685                 return OPVXX2(60, 265, 0) /* xscvdpsp - v2.06 */
4686         case AXSCVSPDP:
4687                 return OPVXX2(60, 329, 0) /* xscvspdp - v2.06 */
4688         case AXSCVDPSPN:
4689                 return OPVXX2(60, 267, 0) /* xscvdpspn - v2.07 */
4690         case AXSCVSPDPN:
4691                 return OPVXX2(60, 331, 0) /* xscvspdpn - v2.07 */
4692
4693         case AXVCVDPSP:
4694                 return OPVXX2(60, 393, 0) /* xvcvdpsp - v2.06 */
4695         case AXVCVSPDP:
4696                 return OPVXX2(60, 457, 0) /* xvcvspdp - v2.06 */
4697
4698         case AXSCVDPSXDS:
4699                 return OPVXX2(60, 344, 0) /* xscvdpsxds - v2.06 */
4700         case AXSCVDPSXWS:
4701                 return OPVXX2(60, 88, 0) /* xscvdpsxws - v2.06 */
4702         case AXSCVDPUXDS:
4703                 return OPVXX2(60, 328, 0) /* xscvdpuxds - v2.06 */
4704         case AXSCVDPUXWS:
4705                 return OPVXX2(60, 72, 0) /* xscvdpuxws - v2.06 */
4706
4707         case AXSCVSXDDP:
4708                 return OPVXX2(60, 376, 0) /* xscvsxddp - v2.06 */
4709         case AXSCVUXDDP:
4710                 return OPVXX2(60, 360, 0) /* xscvuxddp - v2.06 */
4711         case AXSCVSXDSP:
4712                 return OPVXX2(60, 312, 0) /* xscvsxdsp - v2.06 */
4713         case AXSCVUXDSP:
4714                 return OPVXX2(60, 296, 0) /* xscvuxdsp - v2.06 */
4715
4716         case AXVCVDPSXDS:
4717                 return OPVXX2(60, 472, 0) /* xvcvdpsxds - v2.06 */
4718         case AXVCVDPSXWS:
4719                 return OPVXX2(60, 216, 0) /* xvcvdpsxws - v2.06 */
4720         case AXVCVDPUXDS:
4721                 return OPVXX2(60, 456, 0) /* xvcvdpuxds - v2.06 */
4722         case AXVCVDPUXWS:
4723                 return OPVXX2(60, 200, 0) /* xvcvdpuxws - v2.06 */
4724         case AXVCVSPSXDS:
4725                 return OPVXX2(60, 408, 0) /* xvcvspsxds - v2.07 */
4726         case AXVCVSPSXWS:
4727                 return OPVXX2(60, 152, 0) /* xvcvspsxws - v2.07 */
4728         case AXVCVSPUXDS:
4729                 return OPVXX2(60, 392, 0) /* xvcvspuxds - v2.07 */
4730         case AXVCVSPUXWS:
4731                 return OPVXX2(60, 136, 0) /* xvcvspuxws - v2.07 */
4732
4733         case AXVCVSXDDP:
4734                 return OPVXX2(60, 504, 0) /* xvcvsxddp - v2.06 */
4735         case AXVCVSXWDP:
4736                 return OPVXX2(60, 248, 0) /* xvcvsxwdp - v2.06 */
4737         case AXVCVUXDDP:
4738                 return OPVXX2(60, 488, 0) /* xvcvuxddp - v2.06 */
4739         case AXVCVUXWDP:
4740                 return OPVXX2(60, 232, 0) /* xvcvuxwdp - v2.06 */
4741         case AXVCVSXDSP:
4742                 return OPVXX2(60, 440, 0) /* xvcvsxdsp - v2.06 */
4743         case AXVCVSXWSP:
4744                 return OPVXX2(60, 184, 0) /* xvcvsxwsp - v2.06 */
4745         case AXVCVUXDSP:
4746                 return OPVXX2(60, 424, 0) /* xvcvuxdsp - v2.06 */
4747         case AXVCVUXWSP:
4748                 return OPVXX2(60, 168, 0) /* xvcvuxwsp - v2.06 */
4749         /* End of VSX instructions */
4750
4751         case AMADDHD:
4752                 return OPVX(4, 48, 0, 0) /* maddhd - v3.00 */
4753         case AMADDHDU:
4754                 return OPVX(4, 49, 0, 0) /* maddhdu - v3.00 */
4755         case AMADDLD:
4756                 return OPVX(4, 51, 0, 0) /* maddld - v3.00 */
4757
4758         case AXOR:
4759                 return OPVCC(31, 316, 0, 0)
4760         case AXORCC:
4761                 return OPVCC(31, 316, 0, 1)
4762         }
4763
4764         c.ctxt.Diag("bad r/r, r/r/r or r/r/r/r opcode %v", a)
4765         return 0
4766 }
4767
4768 func (c *ctxt9) opirrr(a obj.As) uint32 {
4769         switch a {
4770         /* Vector (VMX/Altivec) instructions */
4771         /* ISA 2.03 enables these for PPC970. For POWERx processors, these */
4772         /* are enabled starting at POWER6 (ISA 2.05). */
4773         case AVSLDOI:
4774                 return OPVX(4, 44, 0, 0) /* vsldoi - v2.03 */
4775         }
4776
4777         c.ctxt.Diag("bad i/r/r/r opcode %v", a)
4778         return 0
4779 }
4780
4781 func (c *ctxt9) opiirr(a obj.As) uint32 {
4782         switch a {
4783         /* Vector (VMX/Altivec) instructions */
4784         /* ISA 2.07 enables these for POWER8 and beyond. */
4785         case AVSHASIGMAW:
4786                 return OPVX(4, 1666, 0, 0) /* vshasigmaw - v2.07 */
4787         case AVSHASIGMAD:
4788                 return OPVX(4, 1730, 0, 0) /* vshasigmad - v2.07 */
4789         }
4790
4791         c.ctxt.Diag("bad i/i/r/r opcode %v", a)
4792         return 0
4793 }
4794
4795 func (c *ctxt9) opirr(a obj.As) uint32 {
4796         switch a {
4797         case AADD:
4798                 return OPVCC(14, 0, 0, 0)
4799         case AADDC:
4800                 return OPVCC(12, 0, 0, 0)
4801         case AADDCCC:
4802                 return OPVCC(13, 0, 0, 0)
4803         case AADDIS:
4804                 return OPVCC(15, 0, 0, 0) /* ADDIS */
4805
4806         case AANDCC:
4807                 return OPVCC(28, 0, 0, 0)
4808         case AANDISCC:
4809                 return OPVCC(29, 0, 0, 0) /* ANDIS. */
4810
4811         case ABR:
4812                 return OPVCC(18, 0, 0, 0)
4813         case ABL:
4814                 return OPVCC(18, 0, 0, 0) | 1
4815         case obj.ADUFFZERO:
4816                 return OPVCC(18, 0, 0, 0) | 1
4817         case obj.ADUFFCOPY:
4818                 return OPVCC(18, 0, 0, 0) | 1
4819         case ABC:
4820                 return OPVCC(16, 0, 0, 0)
4821         case ABCL:
4822                 return OPVCC(16, 0, 0, 0) | 1
4823
4824         case ABEQ:
4825                 return AOP_RRR(16<<26, 12, 2, 0)
4826         case ABGE:
4827                 return AOP_RRR(16<<26, 4, 0, 0)
4828         case ABGT:
4829                 return AOP_RRR(16<<26, 12, 1, 0)
4830         case ABLE:
4831                 return AOP_RRR(16<<26, 4, 1, 0)
4832         case ABLT:
4833                 return AOP_RRR(16<<26, 12, 0, 0)
4834         case ABNE:
4835                 return AOP_RRR(16<<26, 4, 2, 0)
4836         case ABVC:
4837                 return AOP_RRR(16<<26, 4, 3, 0) // apparently unordered-clear
4838         case ABVS:
4839                 return AOP_RRR(16<<26, 12, 3, 0) // apparently unordered-set
4840
4841         case ACMP:
4842                 return OPVCC(11, 0, 0, 0) | 1<<21 /* L=1 */
4843         case ACMPU:
4844                 return OPVCC(10, 0, 0, 0) | 1<<21
4845         case ACMPW:
4846                 return OPVCC(11, 0, 0, 0) /* L=0 */
4847         case ACMPWU:
4848                 return OPVCC(10, 0, 0, 0)
4849         case ACMPEQB:
4850                 return OPVCC(31, 224, 0, 0) /* cmpeqb - v3.00 */
4851
4852         case ALSW:
4853                 return OPVCC(31, 597, 0, 0)
4854
4855         case ACOPY:
4856                 return OPVCC(31, 774, 0, 0) /* copy - v3.00 */
4857         case APASTECC:
4858                 return OPVCC(31, 902, 0, 1) /* paste. - v3.00 */
4859         case ADARN:
4860                 return OPVCC(31, 755, 0, 0) /* darn - v3.00 */
4861
4862         case AMULLW, AMULLD:
4863                 return OPVCC(7, 0, 0, 0) /* mulli works with MULLW or MULLD */
4864
4865         case AOR:
4866                 return OPVCC(24, 0, 0, 0)
4867         case AORIS:
4868                 return OPVCC(25, 0, 0, 0) /* ORIS */
4869
4870         case ARLWMI:
4871                 return OPVCC(20, 0, 0, 0) /* rlwimi */
4872         case ARLWMICC:
4873                 return OPVCC(20, 0, 0, 1)
4874         case ARLDMI:
4875                 return OPMD(30, 3, 0) /* rldimi */
4876         case ARLDMICC:
4877                 return OPMD(30, 3, 1) /* rldimi. */
4878         case ARLDIMI:
4879                 return OPMD(30, 3, 0) /* rldimi */
4880         case ARLDIMICC:
4881                 return OPMD(30, 3, 1) /* rldimi. */
4882         case ARLWNM:
4883                 return OPVCC(21, 0, 0, 0) /* rlwinm */
4884         case ARLWNMCC:
4885                 return OPVCC(21, 0, 0, 1)
4886
4887         case ARLDCL:
4888                 return OPMD(30, 0, 0) /* rldicl */
4889         case ARLDCLCC:
4890                 return OPMD(30, 0, 1) /* rldicl. */
4891         case ARLDCR:
4892                 return OPMD(30, 1, 0) /* rldicr */
4893         case ARLDCRCC:
4894                 return OPMD(30, 1, 1) /* rldicr. */
4895         case ARLDC:
4896                 return OPMD(30, 2, 0) /* rldic */
4897         case ARLDCCC:
4898                 return OPMD(30, 2, 1) /* rldic. */
4899
4900         case ASRAW:
4901                 return OPVCC(31, 824, 0, 0)
4902         case ASRAWCC:
4903                 return OPVCC(31, 824, 0, 1)
4904         case ASRAD:
4905                 return OPVCC(31, (413 << 1), 0, 0)
4906         case ASRADCC:
4907                 return OPVCC(31, (413 << 1), 0, 1)
4908         case AEXTSWSLI:
4909                 return OPVCC(31, 445, 0, 0)
4910         case AEXTSWSLICC:
4911                 return OPVCC(31, 445, 0, 1)
4912
4913         case ASTSW:
4914                 return OPVCC(31, 725, 0, 0)
4915
4916         case ASUBC:
4917                 return OPVCC(8, 0, 0, 0)
4918
4919         case ATW:
4920                 return OPVCC(3, 0, 0, 0)
4921         case ATD:
4922                 return OPVCC(2, 0, 0, 0)
4923
4924         /* Vector (VMX/Altivec) instructions */
4925         /* ISA 2.03 enables these for PPC970. For POWERx processors, these */
4926         /* are enabled starting at POWER6 (ISA 2.05). */
4927         case AVSPLTB:
4928                 return OPVX(4, 524, 0, 0) /* vspltb - v2.03 */
4929         case AVSPLTH:
4930                 return OPVX(4, 588, 0, 0) /* vsplth - v2.03 */
4931         case AVSPLTW:
4932                 return OPVX(4, 652, 0, 0) /* vspltw - v2.03 */
4933
4934         case AVSPLTISB:
4935                 return OPVX(4, 780, 0, 0) /* vspltisb - v2.03 */
4936         case AVSPLTISH:
4937                 return OPVX(4, 844, 0, 0) /* vspltish - v2.03 */
4938         case AVSPLTISW:
4939                 return OPVX(4, 908, 0, 0) /* vspltisw - v2.03 */
4940         /* End of vector instructions */
4941
4942         case AFTDIV:
4943                 return OPVCC(63, 128, 0, 0) /* ftdiv - v2.06 */
4944         case AFTSQRT:
4945                 return OPVCC(63, 160, 0, 0) /* ftsqrt - v2.06 */
4946
4947         case AXOR:
4948                 return OPVCC(26, 0, 0, 0) /* XORIL */
4949         case AXORIS:
4950                 return OPVCC(27, 0, 0, 0) /* XORIS */
4951         }
4952
4953         c.ctxt.Diag("bad opcode i/r or i/r/r %v", a)
4954         return 0
4955 }
4956
4957 /*
4958  * load o(a),d
4959  */
4960 func (c *ctxt9) opload(a obj.As) uint32 {
4961         switch a {
4962         case AMOVD:
4963                 return OPVCC(58, 0, 0, 0) /* ld */
4964         case AMOVDU:
4965                 return OPVCC(58, 0, 0, 1) /* ldu */
4966         case AMOVWZ:
4967                 return OPVCC(32, 0, 0, 0) /* lwz */
4968         case AMOVWZU:
4969                 return OPVCC(33, 0, 0, 0) /* lwzu */
4970         case AMOVW:
4971                 return OPVCC(58, 0, 0, 0) | 1<<1 /* lwa */
4972         case ALXV:
4973                 return OPDQ(61, 1, 0) /* lxv - ISA v3.0 */
4974         case ALXVL:
4975                 return OPVXX1(31, 269, 0) /* lxvl - ISA v3.0 */
4976         case ALXVLL:
4977                 return OPVXX1(31, 301, 0) /* lxvll - ISA v3.0 */
4978         case ALXVX:
4979                 return OPVXX1(31, 268, 0) /* lxvx - ISA v3.0 */
4980
4981                 /* no AMOVWU */
4982         case AMOVB, AMOVBZ:
4983                 return OPVCC(34, 0, 0, 0)
4984                 /* load */
4985
4986         case AMOVBU, AMOVBZU:
4987                 return OPVCC(35, 0, 0, 0)
4988         case AFMOVD:
4989                 return OPVCC(50, 0, 0, 0)
4990         case AFMOVDU:
4991                 return OPVCC(51, 0, 0, 0)
4992         case AFMOVS:
4993                 return OPVCC(48, 0, 0, 0)
4994         case AFMOVSU:
4995                 return OPVCC(49, 0, 0, 0)
4996         case AMOVH:
4997                 return OPVCC(42, 0, 0, 0)
4998         case AMOVHU:
4999                 return OPVCC(43, 0, 0, 0)
5000         case AMOVHZ:
5001                 return OPVCC(40, 0, 0, 0)
5002         case AMOVHZU:
5003                 return OPVCC(41, 0, 0, 0)
5004         case AMOVMW:
5005                 return OPVCC(46, 0, 0, 0) /* lmw */
5006         }
5007
5008         c.ctxt.Diag("bad load opcode %v", a)
5009         return 0
5010 }
5011
5012 /*
5013  * indexed load a(b),d
5014  */
5015 func (c *ctxt9) oploadx(a obj.As) uint32 {
5016         switch a {
5017         case AMOVWZ:
5018                 return OPVCC(31, 23, 0, 0) /* lwzx */
5019         case AMOVWZU:
5020                 return OPVCC(31, 55, 0, 0) /* lwzux */
5021         case AMOVW:
5022                 return OPVCC(31, 341, 0, 0) /* lwax */
5023         case AMOVWU:
5024                 return OPVCC(31, 373, 0, 0) /* lwaux */
5025
5026         case AMOVB, AMOVBZ:
5027                 return OPVCC(31, 87, 0, 0) /* lbzx */
5028
5029         case AMOVBU, AMOVBZU:
5030                 return OPVCC(31, 119, 0, 0) /* lbzux */
5031         case AFMOVD:
5032                 return OPVCC(31, 599, 0, 0) /* lfdx */
5033         case AFMOVDU:
5034                 return OPVCC(31, 631, 0, 0) /*  lfdux */
5035         case AFMOVS:
5036                 return OPVCC(31, 535, 0, 0) /* lfsx */
5037         case AFMOVSU:
5038                 return OPVCC(31, 567, 0, 0) /* lfsux */
5039         case AFMOVSX:
5040                 return OPVCC(31, 855, 0, 0) /* lfiwax - power6, isa 2.05 */
5041         case AFMOVSZ:
5042                 return OPVCC(31, 887, 0, 0) /* lfiwzx - power7, isa 2.06 */
5043         case AMOVH:
5044                 return OPVCC(31, 343, 0, 0) /* lhax */
5045         case AMOVHU:
5046                 return OPVCC(31, 375, 0, 0) /* lhaux */
5047         case AMOVHBR:
5048                 return OPVCC(31, 790, 0, 0) /* lhbrx */
5049         case AMOVWBR:
5050                 return OPVCC(31, 534, 0, 0) /* lwbrx */
5051         case AMOVDBR:
5052                 return OPVCC(31, 532, 0, 0) /* ldbrx */
5053         case AMOVHZ:
5054                 return OPVCC(31, 279, 0, 0) /* lhzx */
5055         case AMOVHZU:
5056                 return OPVCC(31, 311, 0, 0) /* lhzux */
5057         case AECIWX:
5058                 return OPVCC(31, 310, 0, 0) /* eciwx */
5059         case ALBAR:
5060                 return OPVCC(31, 52, 0, 0) /* lbarx */
5061         case ALHAR:
5062                 return OPVCC(31, 116, 0, 0) /* lharx */
5063         case ALWAR:
5064                 return OPVCC(31, 20, 0, 0) /* lwarx */
5065         case ALDAR:
5066                 return OPVCC(31, 84, 0, 0) /* ldarx */
5067         case ALSW:
5068                 return OPVCC(31, 533, 0, 0) /* lswx */
5069         case AMOVD:
5070                 return OPVCC(31, 21, 0, 0) /* ldx */
5071         case AMOVDU:
5072                 return OPVCC(31, 53, 0, 0) /* ldux */
5073         case ALDMX:
5074                 return OPVCC(31, 309, 0, 0) /* ldmx */
5075
5076         /* Vector (VMX/Altivec) instructions */
5077         case ALVEBX:
5078                 return OPVCC(31, 7, 0, 0) /* lvebx - v2.03 */
5079         case ALVEHX:
5080                 return OPVCC(31, 39, 0, 0) /* lvehx - v2.03 */
5081         case ALVEWX:
5082                 return OPVCC(31, 71, 0, 0) /* lvewx - v2.03 */
5083         case ALVX:
5084                 return OPVCC(31, 103, 0, 0) /* lvx - v2.03 */
5085         case ALVXL:
5086                 return OPVCC(31, 359, 0, 0) /* lvxl - v2.03 */
5087         case ALVSL:
5088                 return OPVCC(31, 6, 0, 0) /* lvsl - v2.03 */
5089         case ALVSR:
5090                 return OPVCC(31, 38, 0, 0) /* lvsr - v2.03 */
5091                 /* End of vector instructions */
5092
5093         /* Vector scalar (VSX) instructions */
5094         case ALXVX:
5095                 return OPVXX1(31, 268, 0) /* lxvx - ISA v3.0 */
5096         case ALXVD2X:
5097                 return OPVXX1(31, 844, 0) /* lxvd2x - v2.06 */
5098         case ALXVW4X:
5099                 return OPVXX1(31, 780, 0) /* lxvw4x - v2.06 */
5100         case ALXVH8X:
5101                 return OPVXX1(31, 812, 0) /* lxvh8x - v3.00 */
5102         case ALXVB16X:
5103                 return OPVXX1(31, 876, 0) /* lxvb16x - v3.00 */
5104         case ALXVDSX:
5105                 return OPVXX1(31, 332, 0) /* lxvdsx - v2.06 */
5106         case ALXSDX:
5107                 return OPVXX1(31, 588, 0) /* lxsdx - v2.06 */
5108         case ALXSIWAX:
5109                 return OPVXX1(31, 76, 0) /* lxsiwax - v2.07 */
5110         case ALXSIWZX:
5111                 return OPVXX1(31, 12, 0) /* lxsiwzx - v2.07 */
5112         }
5113
5114         c.ctxt.Diag("bad loadx opcode %v", a)
5115         return 0
5116 }
5117
5118 /*
5119  * store s,o(d)
5120  */
5121 func (c *ctxt9) opstore(a obj.As) uint32 {
5122         switch a {
5123         case AMOVB, AMOVBZ:
5124                 return OPVCC(38, 0, 0, 0) /* stb */
5125
5126         case AMOVBU, AMOVBZU:
5127                 return OPVCC(39, 0, 0, 0) /* stbu */
5128         case AFMOVD:
5129                 return OPVCC(54, 0, 0, 0) /* stfd */
5130         case AFMOVDU:
5131                 return OPVCC(55, 0, 0, 0) /* stfdu */
5132         case AFMOVS:
5133                 return OPVCC(52, 0, 0, 0) /* stfs */
5134         case AFMOVSU:
5135                 return OPVCC(53, 0, 0, 0) /* stfsu */
5136
5137         case AMOVHZ, AMOVH:
5138                 return OPVCC(44, 0, 0, 0) /* sth */
5139
5140         case AMOVHZU, AMOVHU:
5141                 return OPVCC(45, 0, 0, 0) /* sthu */
5142         case AMOVMW:
5143                 return OPVCC(47, 0, 0, 0) /* stmw */
5144         case ASTSW:
5145                 return OPVCC(31, 725, 0, 0) /* stswi */
5146
5147         case AMOVWZ, AMOVW:
5148                 return OPVCC(36, 0, 0, 0) /* stw */
5149
5150         case AMOVWZU, AMOVWU:
5151                 return OPVCC(37, 0, 0, 0) /* stwu */
5152         case AMOVD:
5153                 return OPVCC(62, 0, 0, 0) /* std */
5154         case AMOVDU:
5155                 return OPVCC(62, 0, 0, 1) /* stdu */
5156         case ASTXV:
5157                 return OPDQ(61, 5, 0) /* stxv ISA 3.0 */
5158         case ASTXVL:
5159                 return OPVXX1(31, 397, 0) /* stxvl ISA 3.0 */
5160         case ASTXVLL:
5161                 return OPVXX1(31, 429, 0) /* stxvll ISA 3.0 */
5162         case ASTXVX:
5163                 return OPVXX1(31, 396, 0) /* stxvx - ISA v3.0 */
5164
5165         }
5166
5167         c.ctxt.Diag("unknown store opcode %v", a)
5168         return 0
5169 }
5170
5171 /*
5172  * indexed store s,a(b)
5173  */
5174 func (c *ctxt9) opstorex(a obj.As) uint32 {
5175         switch a {
5176         case AMOVB, AMOVBZ:
5177                 return OPVCC(31, 215, 0, 0) /* stbx */
5178
5179         case AMOVBU, AMOVBZU:
5180                 return OPVCC(31, 247, 0, 0) /* stbux */
5181         case AFMOVD:
5182                 return OPVCC(31, 727, 0, 0) /* stfdx */
5183         case AFMOVDU:
5184                 return OPVCC(31, 759, 0, 0) /* stfdux */
5185         case AFMOVS:
5186                 return OPVCC(31, 663, 0, 0) /* stfsx */
5187         case AFMOVSU:
5188                 return OPVCC(31, 695, 0, 0) /* stfsux */
5189         case AFMOVSX:
5190                 return OPVCC(31, 983, 0, 0) /* stfiwx */
5191
5192         case AMOVHZ, AMOVH:
5193                 return OPVCC(31, 407, 0, 0) /* sthx */
5194         case AMOVHBR:
5195                 return OPVCC(31, 918, 0, 0) /* sthbrx */
5196
5197         case AMOVHZU, AMOVHU:
5198                 return OPVCC(31, 439, 0, 0) /* sthux */
5199
5200         case AMOVWZ, AMOVW:
5201                 return OPVCC(31, 151, 0, 0) /* stwx */
5202
5203         case AMOVWZU, AMOVWU:
5204                 return OPVCC(31, 183, 0, 0) /* stwux */
5205         case ASTSW:
5206                 return OPVCC(31, 661, 0, 0) /* stswx */
5207         case AMOVWBR:
5208                 return OPVCC(31, 662, 0, 0) /* stwbrx */
5209         case AMOVDBR:
5210                 return OPVCC(31, 660, 0, 0) /* stdbrx */
5211         case ASTBCCC:
5212                 return OPVCC(31, 694, 0, 1) /* stbcx. */
5213         case ASTHCCC:
5214                 return OPVCC(31, 726, 0, 1) /* sthcx. */
5215         case ASTWCCC:
5216                 return OPVCC(31, 150, 0, 1) /* stwcx. */
5217         case ASTDCCC:
5218                 return OPVCC(31, 214, 0, 1) /* stwdx. */
5219         case AECOWX:
5220                 return OPVCC(31, 438, 0, 0) /* ecowx */
5221         case AMOVD:
5222                 return OPVCC(31, 149, 0, 0) /* stdx */
5223         case AMOVDU:
5224                 return OPVCC(31, 181, 0, 0) /* stdux */
5225
5226         /* Vector (VMX/Altivec) instructions */
5227         case ASTVEBX:
5228                 return OPVCC(31, 135, 0, 0) /* stvebx - v2.03 */
5229         case ASTVEHX:
5230                 return OPVCC(31, 167, 0, 0) /* stvehx - v2.03 */
5231         case ASTVEWX:
5232                 return OPVCC(31, 199, 0, 0) /* stvewx - v2.03 */
5233         case ASTVX:
5234                 return OPVCC(31, 231, 0, 0) /* stvx - v2.03 */
5235         case ASTVXL:
5236                 return OPVCC(31, 487, 0, 0) /* stvxl - v2.03 */
5237                 /* End of vector instructions */
5238
5239         /* Vector scalar (VSX) instructions */
5240         case ASTXVX:
5241                 return OPVXX1(31, 396, 0) /* stxvx - v3.0 */
5242         case ASTXVD2X:
5243                 return OPVXX1(31, 972, 0) /* stxvd2x - v2.06 */
5244         case ASTXVW4X:
5245                 return OPVXX1(31, 908, 0) /* stxvw4x - v2.06 */
5246         case ASTXVH8X:
5247                 return OPVXX1(31, 940, 0) /* stxvh8x - v3.0 */
5248         case ASTXVB16X:
5249                 return OPVXX1(31, 1004, 0) /* stxvb16x - v3.0 */
5250
5251         case ASTXSDX:
5252                 return OPVXX1(31, 716, 0) /* stxsdx - v2.06 */
5253
5254         case ASTXSIWX:
5255                 return OPVXX1(31, 140, 0) /* stxsiwx - v2.07 */
5256
5257                 /* End of vector scalar instructions */
5258
5259         }
5260
5261         c.ctxt.Diag("unknown storex opcode %v", a)
5262         return 0
5263 }