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