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

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