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