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

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