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