lib/Target/ARM/ARMInstrVFP.td

   1 //===- ARMInstrVFP.td - VFP support for ARM -------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file describes the ARM VFP instruction set.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 def SDT_FTOI :
  15 SDTypeProfile<1, 1, [SDTCisVT<0, f32>, SDTCisFP<1>]>;
  16 def SDT_ITOF :
  17 SDTypeProfile<1, 1, [SDTCisFP<0>, SDTCisVT<1, f32>]>;
  18 def SDT_CMPFP0 :
  19 SDTypeProfile<0, 1, [SDTCisFP<0>]>;
  20 def SDT_FMDRR :
  21 SDTypeProfile<1, 2, [SDTCisVT<0, f64>, SDTCisVT<1, i32>,
  22                      SDTCisSameAs<1, 2>]>;
  23
  24 def arm_ftoui  : SDNode<"ARMISD::FTOUI",  SDT_FTOI>;
  25 def arm_ftosi  : SDNode<"ARMISD::FTOSI",  SDT_FTOI>;
  26 def arm_sitof  : SDNode<"ARMISD::SITOF",  SDT_ITOF>;
  27 def arm_uitof  : SDNode<"ARMISD::UITOF",  SDT_ITOF>;
  28 def arm_fmstat : SDNode<"ARMISD::FMSTAT", SDTNone, [SDNPInFlag,SDNPOutFlag]>;
  29 def arm_cmpfp  : SDNode<"ARMISD::CMPFP",  SDT_ARMCmp, [SDNPOutFlag]>;
  30 def arm_cmpfp0 : SDNode<"ARMISD::CMPFPw0",SDT_CMPFP0, [SDNPOutFlag]>;
  31 def arm_fmdrr  : SDNode<"ARMISD::FMDRR",  SDT_FMDRR>;
  32
  33 //===----------------------------------------------------------------------===//
  34 //  Load / store Instructions.
  35 //
  36
  37 let canFoldAsLoad = 1 in {
  38 def FLDD  : ADI5<0b1101, 0b01, (outs DPR:$dst), (ins addrmode5:$addr),
  39                  IIC_fpLoad64, "fldd", "\t$dst, $addr",
  40                  [(set DPR:$dst, (load addrmode5:$addr))]>;
  41
  42 def FLDS  : ASI5<0b1101, 0b01, (outs SPR:$dst), (ins addrmode5:$addr),
  43                  IIC_fpLoad32, "flds", "\t$dst, $addr",
  44                  [(set SPR:$dst, (load addrmode5:$addr))]>;
  45 } // canFoldAsLoad
  46
  47 def FSTD  : ADI5<0b1101, 0b00, (outs), (ins DPR:$src, addrmode5:$addr),
  48                  IIC_fpStore64, "fstd", "\t$src, $addr",
  49                  [(store DPR:$src, addrmode5:$addr)]>;
  50
  51 def FSTS  : ASI5<0b1101, 0b00, (outs), (ins SPR:$src, addrmode5:$addr),
  52                  IIC_fpStore32, "fsts", "\t$src, $addr",
  53                  [(store SPR:$src, addrmode5:$addr)]>;
  54
  55 //===----------------------------------------------------------------------===//
  56 //  Load / store multiple Instructions.
  57 //
  58
  59 let mayLoad = 1, hasExtraDefRegAllocReq = 1 in {
  60 def FLDMD : AXDI5<(outs), (ins addrmode5:$addr, pred:$p, reglist:$wb,
  61                            variable_ops), IIC_fpLoadm,
  62                   "fldm${addr:submode}d${p}\t${addr:base}, $wb",
  63                   []> {
  64   let Inst{20} = 1;
  65 }
  66
  67 def FLDMS : AXSI5<(outs), (ins addrmode5:$addr, pred:$p, reglist:$wb,
  68                            variable_ops), IIC_fpLoadm,
  69                   "fldm${addr:submode}s${p}\t${addr:base}, $wb",
  70                   []> {
  71   let Inst{20} = 1;
  72 }
  73 } // mayLoad, hasExtraDefRegAllocReq
  74
  75 let mayStore = 1, hasExtraSrcRegAllocReq = 1 in {
  76 def FSTMD : AXDI5<(outs), (ins addrmode5:$addr, pred:$p, reglist:$wb,
  77                            variable_ops), IIC_fpStorem,
  78                  "fstm${addr:submode}d${p}\t${addr:base}, $wb",
  79                  []> {
  80   let Inst{20} = 0;
  81 }
  82
  83 def FSTMS : AXSI5<(outs), (ins addrmode5:$addr, pred:$p, reglist:$wb,
  84                            variable_ops), IIC_fpStorem,
  85                  "fstm${addr:submode}s${p}\t${addr:base}, $wb",
  86                  []> {
  87   let Inst{20} = 0;
  88 }
  89 } // mayStore, hasExtraSrcRegAllocReq
  90
  91 // FLDMX, FSTMX - mixing S/D registers for pre-armv6 cores
  92
  93 //===----------------------------------------------------------------------===//
  94 // FP Binary Operations.
  95 //
  96
  97 def FADDD  : ADbI<0b11100011, (outs DPR:$dst), (ins DPR:$a, DPR:$b),
  98                  IIC_fpALU64, "faddd", "\t$dst, $a, $b",
  99                  [(set DPR:$dst, (fadd DPR:$a, DPR:$b))]>;
 100
 101 def FADDS  : ASbIn<0b11100011, (outs SPR:$dst), (ins SPR:$a, SPR:$b),
 102                   IIC_fpALU32, "fadds", "\t$dst, $a, $b",
 103                   [(set SPR:$dst, (fadd SPR:$a, SPR:$b))]>;
 104
 105 // These are encoded as unary instructions.
 106 let Defs = [FPSCR] in {
 107 def FCMPED : ADuI<0b11101011, 0b0100, 0b1100, (outs), (ins DPR:$a, DPR:$b),
 108                  IIC_fpCMP64, "fcmped", "\t$a, $b",
 109                  [(arm_cmpfp DPR:$a, DPR:$b)]>;
 110
 111 def FCMPES : ASuI<0b11101011, 0b0100, 0b1100, (outs), (ins SPR:$a, SPR:$b),
 112                  IIC_fpCMP32, "fcmpes", "\t$a, $b",
 113                  [(arm_cmpfp SPR:$a, SPR:$b)]>;
 114 }
 115
 116 def FDIVD  : ADbI<0b11101000, (outs DPR:$dst), (ins DPR:$a, DPR:$b),
 117                  IIC_fpDIV64, "fdivd", "\t$dst, $a, $b",
 118                  [(set DPR:$dst, (fdiv DPR:$a, DPR:$b))]>;
 119
 120 def FDIVS  : ASbI<0b11101000, (outs SPR:$dst), (ins SPR:$a, SPR:$b),
 121                  IIC_fpDIV32, "fdivs", "\t$dst, $a, $b",
 122                  [(set SPR:$dst, (fdiv SPR:$a, SPR:$b))]>;
 123
 124 def FMULD  : ADbI<0b11100010, (outs DPR:$dst), (ins DPR:$a, DPR:$b),
 125                  IIC_fpMUL64, "fmuld", "\t$dst, $a, $b",
 126                  [(set DPR:$dst, (fmul DPR:$a, DPR:$b))]>;
 127
 128 def FMULS  : ASbIn<0b11100010, (outs SPR:$dst), (ins SPR:$a, SPR:$b),
 129                   IIC_fpMUL32, "fmuls", "\t$dst, $a, $b",
 130                   [(set SPR:$dst, (fmul SPR:$a, SPR:$b))]>;
 131
 132 def FNMULD  : ADbI<0b11100010, (outs DPR:$dst), (ins DPR:$a, DPR:$b),
 133                   IIC_fpMUL64, "fnmuld", "\t$dst, $a, $b",
 134                   [(set DPR:$dst, (fneg (fmul DPR:$a, DPR:$b)))]> {
 135   let Inst{6} = 1;
 136 }
 137
 138 def FNMULS  : ASbI<0b11100010, (outs SPR:$dst), (ins SPR:$a, SPR:$b),
 139                   IIC_fpMUL32, "fnmuls", "\t$dst, $a, $b",
 140                   [(set SPR:$dst, (fneg (fmul SPR:$a, SPR:$b)))]> {
 141   let Inst{6} = 1;
 142 }
 143
 144 // Match reassociated forms only if not sign dependent rounding.
 145 def : Pat<(fmul (fneg DPR:$a), DPR:$b),
 146           (FNMULD DPR:$a, DPR:$b)>, Requires<[NoHonorSignDependentRounding]>;
 147 def : Pat<(fmul (fneg SPR:$a), SPR:$b),
 148           (FNMULS SPR:$a, SPR:$b)>, Requires<[NoHonorSignDependentRounding]>;
 149
 150
 151 def FSUBD  : ADbI<0b11100011, (outs DPR:$dst), (ins DPR:$a, DPR:$b),
 152                  IIC_fpALU64, "fsubd", "\t$dst, $a, $b",
 153                  [(set DPR:$dst, (fsub DPR:$a, DPR:$b))]> {
 154   let Inst{6} = 1;
 155 }
 156
 157 def FSUBS  : ASbIn<0b11100011, (outs SPR:$dst), (ins SPR:$a, SPR:$b),
 158                   IIC_fpALU32, "fsubs", "\t$dst, $a, $b",
 159                   [(set SPR:$dst, (fsub SPR:$a, SPR:$b))]> {
 160   let Inst{6} = 1;
 161 }
 162
 163 //===----------------------------------------------------------------------===//
 164 // FP Unary Operations.
 165 //
 166
 167 def FABSD  : ADuI<0b11101011, 0b0000, 0b1100, (outs DPR:$dst), (ins DPR:$a),
 168                  IIC_fpUNA64, "fabsd", "\t$dst, $a",
 169                  [(set DPR:$dst, (fabs DPR:$a))]>;
 170
 171 def FABSS  : ASuIn<0b11101011, 0b0000, 0b1100, (outs SPR:$dst), (ins SPR:$a),
 172                   IIC_fpUNA32, "fabss", "\t$dst, $a",
 173                   [(set SPR:$dst, (fabs SPR:$a))]>;
 174
 175 let Defs = [FPSCR] in {
 176 def FCMPEZD : ADuI<0b11101011, 0b0101, 0b1100, (outs), (ins DPR:$a),
 177                   IIC_fpCMP64, "fcmpezd", "\t$a",
 178                   [(arm_cmpfp0 DPR:$a)]>;
 179
 180 def FCMPEZS : ASuI<0b11101011, 0b0101, 0b1100, (outs), (ins SPR:$a),
 181                   IIC_fpCMP32, "fcmpezs", "\t$a",
 182                   [(arm_cmpfp0 SPR:$a)]>;
 183 }
 184
 185 def FCVTDS : ASuI<0b11101011, 0b0111, 0b1100, (outs DPR:$dst), (ins SPR:$a),
 186                  IIC_fpCVTDS, "fcvtds", "\t$dst, $a",
 187                  [(set DPR:$dst, (fextend SPR:$a))]>;
 188
 189 // Special case encoding: bits 11-8 is 0b1011.
 190 def FCVTSD : VFPAI<(outs SPR:$dst), (ins DPR:$a), VFPUnaryFrm,
 191                    IIC_fpCVTSD, "fcvtsd", "\t$dst, $a",
 192                    [(set SPR:$dst, (fround DPR:$a))]> {
 193   let Inst{27-23} = 0b11101;
 194   let Inst{21-16} = 0b110111;
 195   let Inst{11-8}  = 0b1011;
 196   let Inst{7-4}   = 0b1100;
 197 }
 198
 199 let neverHasSideEffects = 1 in {
 200 def FCPYD  : ADuI<0b11101011, 0b0000, 0b0100, (outs DPR:$dst), (ins DPR:$a),
 201                  IIC_fpUNA64, "fcpyd", "\t$dst, $a", []>;
 202
 203 def FCPYS  : ASuI<0b11101011, 0b0000, 0b0100, (outs SPR:$dst), (ins SPR:$a),
 204                  IIC_fpUNA32, "fcpys", "\t$dst, $a", []>;
 205 } // neverHasSideEffects
 206
 207 def FNEGD  : ADuI<0b11101011, 0b0001, 0b0100, (outs DPR:$dst), (ins DPR:$a),
 208                  IIC_fpUNA64, "fnegd", "\t$dst, $a",
 209                  [(set DPR:$dst, (fneg DPR:$a))]>;
 210
 211 def FNEGS  : ASuIn<0b11101011, 0b0001, 0b0100, (outs SPR:$dst), (ins SPR:$a),
 212                   IIC_fpUNA32, "fnegs", "\t$dst, $a",
 213                   [(set SPR:$dst, (fneg SPR:$a))]>;
 214
 215 def FSQRTD  : ADuI<0b11101011, 0b0001, 0b1100, (outs DPR:$dst), (ins DPR:$a),
 216                  IIC_fpSQRT64, "fsqrtd", "\t$dst, $a",
 217                  [(set DPR:$dst, (fsqrt DPR:$a))]>;
 218
 219 def FSQRTS  : ASuI<0b11101011, 0b0001, 0b1100, (outs SPR:$dst), (ins SPR:$a),
 220                  IIC_fpSQRT32, "fsqrts", "\t$dst, $a",
 221                  [(set SPR:$dst, (fsqrt SPR:$a))]>;
 222
 223 //===----------------------------------------------------------------------===//
 224 // FP <-> GPR Copies.  Int <-> FP Conversions.
 225 //
 226
 227 def FMRS   : AVConv2I<0b11100001, 0b1010, (outs GPR:$dst), (ins SPR:$src),
 228                  IIC_VMOVSI, "fmrs", "\t$dst, $src",
 229                  [(set GPR:$dst, (bitconvert SPR:$src))]>;
 230
 231 def FMSR   : AVConv4I<0b11100000, 0b1010, (outs SPR:$dst), (ins GPR:$src),
 232                  IIC_VMOVIS, "fmsr", "\t$dst, $src",
 233                  [(set SPR:$dst, (bitconvert GPR:$src))]>;
 234
 235 def FMRRD  : AVConv3I<0b11000101, 0b1011,
 236                       (outs GPR:$wb, GPR:$dst2), (ins DPR:$src),
 237                  IIC_VMOVDI, "fmrrd", "\t$wb, $dst2, $src",
 238                  [/* FIXME: Can't write pattern for multiple result instr*/]>;
 239
 240 // FMDHR: GPR -> SPR
 241 // FMDLR: GPR -> SPR
 242
 243 def FMDRR : AVConv5I<0b11000100, 0b1011,
 244                      (outs DPR:$dst), (ins GPR:$src1, GPR:$src2),
 245                 IIC_VMOVID, "fmdrr", "\t$dst, $src1, $src2",
 246                 [(set DPR:$dst, (arm_fmdrr GPR:$src1, GPR:$src2))]>;
 247
 248 // FMRDH: SPR -> GPR
 249 // FMRDL: SPR -> GPR
 250 // FMRRS: SPR -> GPR
 251 // FMRX : SPR system reg -> GPR
 252
 253 // FMSRR: GPR -> SPR
 254
 255 // FMXR: GPR -> VFP Sstem reg
 256
 257
 258 // Int to FP:
 259
 260 def FSITOD : AVConv1I<0b11101011, 0b1000, 0b1011, (outs DPR:$dst), (ins SPR:$a),
 261                  IIC_fpCVTID, "fsitod", "\t$dst, $a",
 262                  [(set DPR:$dst, (arm_sitof SPR:$a))]> {
 263   let Inst{7} = 1;
 264 }
 265
 266 def FSITOS : AVConv1In<0b11101011, 0b1000, 0b1010, (outs SPR:$dst),(ins SPR:$a),
 267                  IIC_fpCVTIS, "fsitos", "\t$dst, $a",
 268                  [(set SPR:$dst, (arm_sitof SPR:$a))]> {
 269   let Inst{7} = 1;
 270 }
 271
 272 def FUITOD : AVConv1I<0b11101011, 0b1000, 0b1011, (outs DPR:$dst), (ins SPR:$a),
 273                  IIC_fpCVTID, "fuitod", "\t$dst, $a",
 274                  [(set DPR:$dst, (arm_uitof SPR:$a))]>;
 275
 276 def FUITOS : AVConv1In<0b11101011, 0b1000, 0b1010, (outs SPR:$dst),(ins SPR:$a),
 277                  IIC_fpCVTIS, "fuitos", "\t$dst, $a",
 278                  [(set SPR:$dst, (arm_uitof SPR:$a))]>;
 279
 280 // FP to Int:
 281 // Always set Z bit in the instruction, i.e. "round towards zero" variants.
 282
 283 def FTOSIZD : AVConv1I<0b11101011, 0b1101, 0b1011,
 284                        (outs SPR:$dst), (ins DPR:$a),
 285                  IIC_fpCVTDI, "ftosizd", "\t$dst, $a",
 286                  [(set SPR:$dst, (arm_ftosi DPR:$a))]> {
 287   let Inst{7} = 1; // Z bit
 288 }
 289
 290 def FTOSIZS : AVConv1In<0b11101011, 0b1101, 0b1010,
 291                         (outs SPR:$dst), (ins SPR:$a),
 292                  IIC_fpCVTSI, "ftosizs", "\t$dst, $a",
 293                  [(set SPR:$dst, (arm_ftosi SPR:$a))]> {
 294   let Inst{7} = 1; // Z bit
 295 }
 296
 297 def FTOUIZD : AVConv1I<0b11101011, 0b1100, 0b1011,
 298                        (outs SPR:$dst), (ins DPR:$a),
 299                  IIC_fpCVTDI, "ftouizd", "\t$dst, $a",
 300                  [(set SPR:$dst, (arm_ftoui DPR:$a))]> {
 301   let Inst{7} = 1; // Z bit
 302 }
 303
 304 def FTOUIZS : AVConv1In<0b11101011, 0b1100, 0b1010,
 305                         (outs SPR:$dst), (ins SPR:$a),
 306                  IIC_fpCVTSI, "ftouizs", "\t$dst, $a",
 307                  [(set SPR:$dst, (arm_ftoui SPR:$a))]> {
 308   let Inst{7} = 1; // Z bit
 309 }
 310
 311 //===----------------------------------------------------------------------===//
 312 // FP FMA Operations.
 313 //
 314
 315 def FMACD : ADbI<0b11100000, (outs DPR:$dst), (ins DPR:$dstin, DPR:$a, DPR:$b),
 316                 IIC_fpMAC64, "fmacd", "\t$dst, $a, $b",
 317                 [(set DPR:$dst, (fadd (fmul DPR:$a, DPR:$b), DPR:$dstin))]>,
 318                 RegConstraint<"$dstin = $dst">;
 319
 320 def FMACS : ASbIn<0b11100000, (outs SPR:$dst), (ins SPR:$dstin, SPR:$a, SPR:$b),
 321                  IIC_fpMAC32, "fmacs", "\t$dst, $a, $b",
 322                  [(set SPR:$dst, (fadd (fmul SPR:$a, SPR:$b), SPR:$dstin))]>,
 323                  RegConstraint<"$dstin = $dst">;
 324
 325 def FMSCD : ADbI<0b11100001, (outs DPR:$dst), (ins DPR:$dstin, DPR:$a, DPR:$b),
 326                 IIC_fpMAC64, "fmscd", "\t$dst, $a, $b",
 327                 [(set DPR:$dst, (fsub (fmul DPR:$a, DPR:$b), DPR:$dstin))]>,
 328                 RegConstraint<"$dstin = $dst">;
 329
 330 def FMSCS : ASbI<0b11100001, (outs SPR:$dst), (ins SPR:$dstin, SPR:$a, SPR:$b),
 331                 IIC_fpMAC32, "fmscs", "\t$dst, $a, $b",
 332                 [(set SPR:$dst, (fsub (fmul SPR:$a, SPR:$b), SPR:$dstin))]>,
 333                 RegConstraint<"$dstin = $dst">;
 334
 335 def FNMACD : ADbI<0b11100000, (outs DPR:$dst), (ins DPR:$dstin, DPR:$a, DPR:$b),
 336                  IIC_fpMAC64, "fnmacd", "\t$dst, $a, $b",
 337              [(set DPR:$dst, (fadd (fneg (fmul DPR:$a, DPR:$b)), DPR:$dstin))]>,
 338                 RegConstraint<"$dstin = $dst"> {
 339   let Inst{6} = 1;
 340 }
 341
 342 def FNMACS : ASbIn<0b11100000, (outs SPR:$dst), (ins SPR:$dstin, SPR:$a, SPR:$b),
 343                   IIC_fpMAC32, "fnmacs", "\t$dst, $a, $b",
 344              [(set SPR:$dst, (fadd (fneg (fmul SPR:$a, SPR:$b)), SPR:$dstin))]>,
 345                 RegConstraint<"$dstin = $dst"> {
 346   let Inst{6} = 1;
 347 }
 348
 349 def : Pat<(fsub DPR:$dstin, (fmul DPR:$a, DPR:$b)),
 350           (FNMACD DPR:$dstin, DPR:$a, DPR:$b)>, Requires<[DontUseNEONForFP]>;
 351 def : Pat<(fsub SPR:$dstin, (fmul SPR:$a, SPR:$b)),
 352           (FNMACS SPR:$dstin, SPR:$a, SPR:$b)>, Requires<[DontUseNEONForFP]>;
 353
 354 def FNMSCD : ADbI<0b11100001, (outs DPR:$dst), (ins DPR:$dstin, DPR:$a, DPR:$b),
 355                  IIC_fpMAC64, "fnmscd", "\t$dst, $a, $b",
 356              [(set DPR:$dst, (fsub (fneg (fmul DPR:$a, DPR:$b)), DPR:$dstin))]>,
 357                 RegConstraint<"$dstin = $dst"> {
 358   let Inst{6} = 1;
 359 }
 360
 361 def FNMSCS : ASbI<0b11100001, (outs SPR:$dst), (ins SPR:$dstin, SPR:$a, SPR:$b),
 362                 IIC_fpMAC32, "fnmscs", "\t$dst, $a, $b",
 363              [(set SPR:$dst, (fsub (fneg (fmul SPR:$a, SPR:$b)), SPR:$dstin))]>,
 364                 RegConstraint<"$dstin = $dst"> {
 365   let Inst{6} = 1;
 366 }
 367
 368 //===----------------------------------------------------------------------===//
 369 // FP Conditional moves.
 370 //
 371
 372 def FCPYDcc  : ADuI<0b11101011, 0b0000, 0b0100,
 373                     (outs DPR:$dst), (ins DPR:$false, DPR:$true),
 374                     IIC_fpUNA64, "fcpyd", "\t$dst, $true",
 375                 [/*(set DPR:$dst, (ARMcmov DPR:$false, DPR:$true, imm:$cc))*/]>,
 376                     RegConstraint<"$false = $dst">;
 377
 378 def FCPYScc  : ASuI<0b11101011, 0b0000, 0b0100,
 379                     (outs SPR:$dst), (ins SPR:$false, SPR:$true),
 380                     IIC_fpUNA32, "fcpys", "\t$dst, $true",
 381                 [/*(set SPR:$dst, (ARMcmov SPR:$false, SPR:$true, imm:$cc))*/]>,
 382                     RegConstraint<"$false = $dst">;
 383
 384 def FNEGDcc  : ADuI<0b11101011, 0b0001, 0b0100,
 385                     (outs DPR:$dst), (ins DPR:$false, DPR:$true),
 386                     IIC_fpUNA64, "fnegd", "\t$dst, $true",
 387                 [/*(set DPR:$dst, (ARMcneg DPR:$false, DPR:$true, imm:$cc))*/]>,
 388                     RegConstraint<"$false = $dst">;
 389
 390 def FNEGScc  : ASuI<0b11101011, 0b0001, 0b0100,
 391                     (outs SPR:$dst), (ins SPR:$false, SPR:$true),
 392                     IIC_fpUNA32, "fnegs", "\t$dst, $true",
 393                 [/*(set SPR:$dst, (ARMcneg SPR:$false, SPR:$true, imm:$cc))*/]>,
 394                     RegConstraint<"$false = $dst">;
 395
 396
 397 //===----------------------------------------------------------------------===//
 398 // Misc.
 399 //
 400
 401 let Defs = [CPSR], Uses = [FPSCR] in
 402 def FMSTAT : VFPAI<(outs), (ins), VFPMiscFrm, IIC_fpSTAT, "fmstat", "",
 403              [(arm_fmstat)]> {
 404   let Inst{27-20} = 0b11101111;
 405   let Inst{19-16} = 0b0001;
 406   let Inst{15-12} = 0b1111;
 407   let Inst{11-8}  = 0b1010;
 408   let Inst{7}     = 0;
 409   let Inst{4}     = 1;
 410 }