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