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