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

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