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