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