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

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