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