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