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