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