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