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