contrib/llvm/lib/Target/Hexagon/HexagonInstrInfoV60.td

   1 //=- HexagonInstrInfoV60.td - Target Desc. for Hexagon Target -*- tablegen -*-=//
   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 Hexagon V60 instructions in TableGen format.
  11 //
  12 //===----------------------------------------------------------------------===//
  13 // Vector load
  14 let Predicates = [HasV60T, UseHVX] in
  15 let mayLoad = 1, validSubTargets = HasV60SubT, hasSideEffects = 0 in
  16   class V6_LDInst<dag outs, dag ins, string asmstr, list<dag> pattern = [],
  17                   string cstr = "", InstrItinClass itin = CVI_VM_LD,
  18                   IType type = TypeCVI_VM_LD>
  19   : InstHexagon<outs, ins, asmstr, pattern, cstr, itin, type>;
  20
  21 // Vector store
  22 let Predicates = [HasV60T, UseHVX] in
  23 let mayStore = 1, validSubTargets = HasV60SubT, hasSideEffects = 0 in
  24 class V6_STInst<dag outs, dag ins, string asmstr, list<dag> pattern = [],
  25                 string cstr = "", InstrItinClass itin = CVI_VM_ST,
  26                 IType type = TypeCVI_VM_ST>
  27 : InstHexagon<outs, ins, asmstr, pattern, cstr, itin, type>;
  28
  29 //===----------------------------------------------------------------------===//
  30 // Vector loads with base + immediate offset
  31 //===----------------------------------------------------------------------===//
  32 let addrMode = BaseImmOffset, accessSize = Vector64Access in
  33 class T_vload_ai<string asmStr>
  34   : V6_LDInst <(outs VectorRegs:$dst), (ins IntRegs:$src1, s4_6Imm:$src2),
  35                 asmStr>;
  36
  37 let isCodeGenOnly = 1, addrMode = BaseImmOffset, accessSize = Vector128Access in
  38 class T_vload_ai_128B<string asmStr>
  39   : V6_LDInst <(outs VectorRegs128B:$dst), (ins IntRegs:$src1, s4_7Imm:$src2),
  40                 asmStr>;
  41
  42 let isCVLoadable = 1, hasNewValue = 1 in {
  43   def V6_vL32b_ai         : T_vload_ai <"$dst = vmem($src1+#$src2)">,
  44                             V6_vL32b_ai_enc;
  45   def V6_vL32b_nt_ai      : T_vload_ai <"$dst = vmem($src1+#$src2):nt">,
  46                             V6_vL32b_nt_ai_enc;
  47   // 128B
  48   def V6_vL32b_ai_128B    : T_vload_ai_128B <"$dst = vmem($src1+#$src2)">,
  49                             V6_vL32b_ai_128B_enc;
  50   def V6_vL32b_nt_ai_128B : T_vload_ai_128B <"$dst = vmem($src1+#$src2):nt">,
  51                             V6_vL32b_nt_ai_128B_enc;
  52 }
  53
  54 let Itinerary = CVI_VM_VP_LDU, Type = TypeCVI_VM_VP_LDU, hasNewValue = 1 in {
  55   def V6_vL32Ub_ai      : T_vload_ai <"$dst = vmemu($src1+#$src2)">,
  56                           V6_vL32Ub_ai_enc;
  57   def V6_vL32Ub_ai_128B : T_vload_ai_128B <"$dst = vmemu($src1+#$src2)">,
  58                           V6_vL32Ub_ai_128B_enc;
  59 }
  60
  61 let Itinerary = CVI_VM_LD, Type = TypeCVI_VM_LD, isCVLoad = 1,
  62     hasNewValue = 1 in {
  63   def V6_vL32b_cur_ai    : T_vload_ai <"$dst.cur = vmem($src1+#$src2)">,
  64                            V6_vL32b_cur_ai_enc;
  65   def V6_vL32b_nt_cur_ai : T_vload_ai <"$dst.cur = vmem($src1+#$src2):nt">,
  66                            V6_vL32b_nt_cur_ai_enc;
  67   // 128B
  68   def V6_vL32b_cur_ai_128B    : T_vload_ai_128B
  69                                 <"$dst.cur = vmem($src1+#$src2)">,
  70                                 V6_vL32b_cur_ai_128B_enc;
  71   def V6_vL32b_nt_cur_ai_128B : T_vload_ai_128B
  72                                 <"$dst.cur = vmem($src1+#$src2):nt">,
  73                                 V6_vL32b_nt_cur_ai_128B_enc;
  74 }
  75
  76
  77 let Itinerary = CVI_VM_TMP_LD, Type = TypeCVI_VM_TMP_LD, hasNewValue = 1 in {
  78   def V6_vL32b_tmp_ai    : T_vload_ai <"$dst.tmp = vmem($src1+#$src2)">,
  79                            V6_vL32b_tmp_ai_enc;
  80   def V6_vL32b_nt_tmp_ai : T_vload_ai <"$dst.tmp = vmem($src1+#$src2):nt">,
  81                            V6_vL32b_nt_tmp_ai_enc;
  82   // 128B
  83   def V6_vL32b_tmp_ai_128B    : T_vload_ai_128B
  84                                 <"$dst.tmp = vmem($src1+#$src2)">,
  85                                 V6_vL32b_tmp_ai_128B_enc;
  86   def V6_vL32b_nt_tmp_ai_128B : T_vload_ai_128B
  87                                 <"$dst.tmp = vmem($src1+#$src2)">,
  88                                 V6_vL32b_nt_tmp_ai_128B_enc;
  89 }
  90
  91 //===----------------------------------------------------------------------===//
  92 // Vector stores with base + immediate offset - unconditional
  93 //===----------------------------------------------------------------------===//
  94 let addrMode = BaseImmOffset, accessSize = Vector64Access, isPredicable = 1 in
  95 class T_vstore_ai <string mnemonic, string baseOp, Operand ImmOp,
  96                    RegisterClass RC, bit isNT>
  97   : V6_STInst <(outs), (ins IntRegs:$src1, ImmOp:$src2, RC:$src3),
  98     mnemonic#"($src1+#$src2)"#!if(isNT, ":nt", "")#" = $src3">, NewValueRel {
  99   let BaseOpcode = baseOp;
 100 }
 101
 102 let accessSize = Vector64Access in
 103 class T_vstore_ai_64B <string mnemonic, string baseOp, bit isNT = 0>
 104   : T_vstore_ai <mnemonic, baseOp, s4_6Imm, VectorRegs, isNT>;
 105
 106 let isCodeGenOnly = 1, accessSize = Vector128Access in
 107 class T_vstore_ai_128B <string mnemonic, string baseOp, bit isNT = 0>
 108   : T_vstore_ai <mnemonic, baseOp#"128B", s4_7Imm, VectorRegs128B, isNT>;
 109
 110 let isNVStorable = 1 in {
 111   def V6_vS32b_ai         : T_vstore_ai_64B <"vmem", "vS32b_ai">,
 112                             V6_vS32b_ai_enc;
 113   def V6_vS32b_ai_128B    : T_vstore_ai_128B <"vmem", "vS32b_ai">,
 114                             V6_vS32b_ai_128B_enc;
 115 }
 116
 117 let isNVStorable = 1, isNonTemporal = 1 in {
 118   def V6_vS32b_nt_ai      : T_vstore_ai_64B <"vmem", "vS32b_ai", 1>,
 119                             V6_vS32b_nt_ai_enc;
 120   def V6_vS32b_nt_ai_128B : T_vstore_ai_128B <"vmem", "vS32b_ai", 1>,
 121                             V6_vS32b_nt_ai_128B_enc;
 122 }
 123
 124 let Itinerary = CVI_VM_STU, Type = TypeCVI_VM_STU in {
 125   def V6_vS32Ub_ai      : T_vstore_ai_64B <"vmemu", "vS32Ub_ai">,
 126                           V6_vS32Ub_ai_enc;
 127   def V6_vS32Ub_ai_128B : T_vstore_ai_128B <"vmemu", "vS32Ub_ai">,
 128                           V6_vS32Ub_ai_128B_enc;
 129 }
 130 //===----------------------------------------------------------------------===//
 131 // Vector stores with base + immediate offset - unconditional new
 132 //===----------------------------------------------------------------------===//
 133 let addrMode = BaseImmOffset, isNewValue = 1, opNewValue = 2, isNVStore = 1,
 134     isPredicable = 1, Itinerary = CVI_VM_NEW_ST, Type = TypeCVI_VM_NEW_ST in
 135 class T_vstore_new_ai <string baseOp, Operand ImmOp, RegisterClass RC, bit isNT>
 136   : V6_STInst <(outs ), (ins IntRegs:$src1, ImmOp:$src2, RC:$src3),
 137     "vmem($src1+#$src2)"#!if(isNT, ":nt", "")#" = $src3.new">, NewValueRel {
 138   let BaseOpcode = baseOp;
 139 }
 140
 141 let accessSize = Vector64Access in
 142 class T_vstore_new_ai_64B <string baseOp, bit isNT = 0>
 143   : T_vstore_new_ai <baseOp, s4_6Imm, VectorRegs, isNT>;
 144
 145 let isCodeGenOnly = 1, accessSize = Vector128Access in
 146 class T_vstore_new_ai_128B <string baseOp, bit isNT = 0>
 147   : T_vstore_new_ai <baseOp#"128B", s4_7Imm, VectorRegs128B, isNT>;
 148
 149 def V6_vS32b_new_ai      : T_vstore_new_ai_64B <"vS32b_ai">, V6_vS32b_new_ai_enc;
 150 def V6_vS32b_new_ai_128B : T_vstore_new_ai_128B <"vS32b_ai">,
 151                            V6_vS32b_new_ai_128B_enc;
 152
 153 let isNonTemporal = 1 in {
 154   def V6_vS32b_nt_new_ai      : T_vstore_new_ai_64B<"vS32b_ai", 1>,
 155                                 V6_vS32b_nt_new_ai_enc;
 156   def V6_vS32b_nt_new_ai_128B : T_vstore_new_ai_128B<"vS32b_ai", 1>,
 157                                 V6_vS32b_nt_new_ai_128B_enc;
 158 }
 159
 160 //===----------------------------------------------------------------------===//
 161 // Vector stores with base + immediate offset - conditional
 162 //===----------------------------------------------------------------------===//
 163 let addrMode = BaseImmOffset, isPredicated = 1 in
 164 class T_vstore_pred_ai <string mnemonic, string baseOp, Operand ImmOp,
 165                         RegisterClass RC, bit isPredNot = 0, bit isNT = 0>
 166   : V6_STInst <(outs),
 167                (ins PredRegs:$src1, IntRegs:$src2, ImmOp:$src3, RC:$src4),
 168     "if ("#!if(isPredNot, "!", "")#"$src1) "
 169      #mnemonic#"($src2+#$src3)"#!if(isNT, ":nt", "")#" = $src4">, NewValueRel {
 170   let isPredicatedFalse = isPredNot;
 171   let BaseOpcode = baseOp;
 172 }
 173
 174 let accessSize = Vector64Access in
 175 class T_vstore_pred_ai_64B <string mnemonic, string baseOp,
 176                             bit isPredNot = 0, bit isNT = 0>
 177   : T_vstore_pred_ai <mnemonic, baseOp, s4_6Imm, VectorRegs, isPredNot, isNT>;
 178
 179 let isCodeGenOnly = 1, accessSize = Vector128Access in
 180 class T_vstore_pred_ai_128B <string mnemonic, string baseOp,
 181                              bit isPredNot = 0, bit isNT = 0>
 182   : T_vstore_pred_ai <mnemonic, baseOp#"128B", s4_7Imm, VectorRegs128B,
 183                       isPredNot, isNT>;
 184
 185 let isNVStorable = 1 in {
 186   def V6_vS32b_pred_ai     : T_vstore_pred_ai_64B <"vmem", "vS32b_ai">,
 187                              V6_vS32b_pred_ai_enc;
 188   def V6_vS32b_npred_ai    : T_vstore_pred_ai_64B <"vmem", "vS32b_ai", 1>,
 189                              V6_vS32b_npred_ai_enc;
 190   // 128B
 191   def V6_vS32b_pred_ai_128B    : T_vstore_pred_ai_128B <"vmem", "vS32b_ai">,
 192                                  V6_vS32b_pred_ai_128B_enc;
 193   def V6_vS32b_npred_ai_128B   : T_vstore_pred_ai_128B <"vmem", "vS32b_ai", 1>,
 194                                  V6_vS32b_npred_ai_128B_enc;
 195 }
 196
 197
 198 let isNVStorable = 1, isNonTemporal = 1 in {
 199   def V6_vS32b_nt_pred_ai  : T_vstore_pred_ai_64B <"vmem", "vS32b_ai", 0, 1>,
 200                              V6_vS32b_nt_pred_ai_enc;
 201   def V6_vS32b_nt_npred_ai : T_vstore_pred_ai_64B <"vmem", "vS32b_ai", 1, 1>,
 202                              V6_vS32b_nt_npred_ai_enc;
 203   // 128B
 204   def V6_vS32b_nt_pred_ai_128B  : T_vstore_pred_ai_128B
 205                                   <"vmem", "vS32b_ai", 0, 1>,
 206                                   V6_vS32b_nt_pred_ai_128B_enc;
 207   def V6_vS32b_nt_npred_ai_128B : T_vstore_pred_ai_128B
 208                                   <"vmem", "vS32b_ai", 1, 1>,
 209                                   V6_vS32b_nt_npred_ai_128B_enc;
 210 }
 211
 212 let Itinerary = CVI_VM_STU, Type = TypeCVI_VM_STU in {
 213   def V6_vS32Ub_pred_ai  : T_vstore_pred_ai_64B <"vmemu", "vS32Ub_ai">,
 214                            V6_vS32Ub_pred_ai_enc;
 215   def V6_vS32Ub_npred_ai : T_vstore_pred_ai_64B <"vmemu", "vS32Ub_ai", 1>,
 216                            V6_vS32Ub_npred_ai_enc;
 217   // 128B
 218   def V6_vS32Ub_pred_ai_128B  :T_vstore_pred_ai_128B <"vmemu", "vS32Ub_ai">,
 219                                V6_vS32Ub_pred_ai_128B_enc;
 220   def V6_vS32Ub_npred_ai_128B :T_vstore_pred_ai_128B <"vmemu", "vS32Ub_ai", 1>,
 221                                V6_vS32Ub_npred_ai_128B_enc;
 222 }
 223
 224 //===----------------------------------------------------------------------===//
 225 // Vector stores with base + immediate offset - byte-enabled aligned
 226 //===----------------------------------------------------------------------===//
 227 let addrMode = BaseImmOffset in
 228 class T_vstore_qpred_ai <Operand ImmOp, RegisterClass RC,
 229                          bit isPredNot = 0, bit isNT = 0>
 230   : V6_STInst <(outs),
 231                (ins VecPredRegs:$src1, IntRegs:$src2, ImmOp:$src3, RC:$src4),
 232     "if ("#!if(isPredNot, "!", "")#"$src1) vmem($src2+#$src3)"
 233           #!if(isNT, ":nt", "")#" = $src4"> {
 234   let isPredicatedFalse = isPredNot;
 235 }
 236
 237 let accessSize = Vector64Access in
 238 class T_vstore_qpred_ai_64B <bit isPredNot = 0, bit isNT = 0>
 239   : T_vstore_qpred_ai <s4_6Imm, VectorRegs, isPredNot, isNT>;
 240
 241 let isCodeGenOnly = 1, accessSize = Vector128Access in
 242 class T_vstore_qpred_ai_128B <bit isPredNot = 0, bit isNT = 0>
 243   : T_vstore_qpred_ai <s4_7Imm, VectorRegs128B, isPredNot, isNT>;
 244
 245 def V6_vS32b_qpred_ai  : T_vstore_qpred_ai_64B, V6_vS32b_qpred_ai_enc;
 246 def V6_vS32b_nqpred_ai : T_vstore_qpred_ai_64B <1>,
 247                          V6_vS32b_nqpred_ai_enc;
 248 def V6_vS32b_nt_qpred_ai  : T_vstore_qpred_ai_64B <0, 1>,
 249                             V6_vS32b_nt_qpred_ai_enc;
 250 def V6_vS32b_nt_nqpred_ai : T_vstore_qpred_ai_64B <1, 1>,
 251                             V6_vS32b_nt_nqpred_ai_enc;
 252 // 128B
 253 def V6_vS32b_qpred_ai_128B  : T_vstore_qpred_ai_128B, V6_vS32b_qpred_ai_128B_enc;
 254 def V6_vS32b_nqpred_ai_128B : T_vstore_qpred_ai_128B<1>,
 255                               V6_vS32b_nqpred_ai_128B_enc;
 256 def V6_vS32b_nt_qpred_ai_128B  : T_vstore_qpred_ai_128B<0, 1>,
 257                                  V6_vS32b_nt_qpred_ai_128B_enc;
 258 def V6_vS32b_nt_nqpred_ai_128B : T_vstore_qpred_ai_128B<1, 1>,
 259                                  V6_vS32b_nt_nqpred_ai_128B_enc;
 260
 261
 262 //===----------------------------------------------------------------------===//
 263 // Vector stores with base + immediate offset - conditional new
 264 //===----------------------------------------------------------------------===//
 265 let addrMode = BaseImmOffset, isPredicated = 1, isNewValue = 1, opNewValue = 3,
 266     isNVStore = 1, Type = TypeCVI_VM_NEW_ST, Itinerary = CVI_VM_NEW_ST in
 267 class T_vstore_new_pred_ai <string baseOp, Operand ImmOp, RegisterClass RC,
 268                             bit isPredNot, bit isNT>
 269   : V6_STInst <(outs),
 270                (ins PredRegs:$src1, IntRegs:$src2, ImmOp:$src3, RC:$src4),
 271     "if("#!if(isPredNot, "!", "")#"$src1) vmem($src2+#$src3)"
 272          #!if(isNT, ":nt", "")#" = $src4.new">, NewValueRel {
 273   let isPredicatedFalse = isPredNot;
 274   let BaseOpcode = baseOp;
 275 }
 276
 277 let accessSize = Vector64Access in
 278 class T_vstore_new_pred_ai_64B <string baseOp, bit isPredNot = 0, bit isNT = 0>
 279   : T_vstore_new_pred_ai <baseOp, s4_6Imm, VectorRegs, isPredNot, isNT>;
 280
 281 let isCodeGenOnly = 1, accessSize = Vector128Access in
 282 class T_vstore_new_pred_ai_128B <string baseOp, bit isPredNot = 0, bit isNT = 0>
 283   : T_vstore_new_pred_ai <baseOp#"128B", s4_7Imm, VectorRegs128B,
 284                           isPredNot, isNT>;
 285
 286
 287 def V6_vS32b_new_pred_ai     : T_vstore_new_pred_ai_64B <"vS32b_ai">,
 288                                V6_vS32b_new_pred_ai_enc;
 289 def V6_vS32b_new_npred_ai    : T_vstore_new_pred_ai_64B <"vS32b_ai", 1>,
 290                                V6_vS32b_new_npred_ai_enc;
 291 // 128B
 292 def V6_vS32b_new_pred_ai_128B     : T_vstore_new_pred_ai_128B <"vS32b_ai">,
 293                                     V6_vS32b_new_pred_ai_128B_enc;
 294 def V6_vS32b_new_npred_ai_128B    : T_vstore_new_pred_ai_128B <"vS32b_ai", 1>,
 295                                     V6_vS32b_new_npred_ai_128B_enc;
 296 let isNonTemporal = 1 in {
 297   def V6_vS32b_nt_new_pred_ai  : T_vstore_new_pred_ai_64B <"vS32b_ai", 0, 1>,
 298                                  V6_vS32b_nt_new_pred_ai_enc;
 299   def V6_vS32b_nt_new_npred_ai : T_vstore_new_pred_ai_64B <"vS32b_ai", 1, 1>,
 300                                  V6_vS32b_nt_new_npred_ai_enc;
 301   // 128B
 302   def V6_vS32b_nt_new_pred_ai_128B  : T_vstore_new_pred_ai_128B
 303                                       <"vS32b_ai", 0, 1>,
 304                                       V6_vS32b_nt_new_pred_ai_128B_enc;
 305   def V6_vS32b_nt_new_npred_ai_128B : T_vstore_new_pred_ai_128B
 306                                       <"vS32b_ai", 1, 1>,
 307                                       V6_vS32b_nt_new_npred_ai_128B_enc;
 308 }
 309
 310 //===----------------------------------------------------------------------===//
 311 // Post increment vector loads with immediate offset.
 312 //===----------------------------------------------------------------------===//
 313 let addrMode = PostInc, hasNewValue = 1 in
 314 class T_vload_pi<string asmStr, Operand ImmOp, RegisterClass RC>
 315   : V6_LDInst <(outs RC:$dst, IntRegs:$_dst_),
 316                (ins IntRegs:$src1, ImmOp:$src2), asmStr, [],
 317     "$src1 = $_dst_">;
 318
 319 let accessSize = Vector64Access in
 320 class T_vload_pi_64B <string asmStr>
 321   : T_vload_pi <asmStr, s3_6Imm, VectorRegs>;
 322
 323 let isCodeGenOnly = 1, accessSize = Vector128Access in
 324 class T_vload_pi_128B <string asmStr>
 325   : T_vload_pi <asmStr, s3_7Imm, VectorRegs128B>;
 326
 327 let isCVLoadable = 1 in {
 328   def V6_vL32b_pi    : T_vload_pi_64B <"$dst = vmem($src1++#$src2)">,
 329                        V6_vL32b_pi_enc;
 330   def V6_vL32b_nt_pi : T_vload_pi_64B <"$dst = vmem($src1++#$src2):nt">,
 331                        V6_vL32b_nt_pi_enc;
 332   // 128B
 333   def V6_vL32b_pi_128B    : T_vload_pi_128B <"$dst = vmem($src1++#$src2)">,
 334                             V6_vL32b_pi_128B_enc;
 335   def V6_vL32b_nt_pi_128B : T_vload_pi_128B <"$dst = vmem($src1++#$src2):nt">,
 336                             V6_vL32b_nt_pi_128B_enc;
 337 }
 338
 339 let Itinerary = CVI_VM_VP_LDU, Type = TypeCVI_VM_VP_LDU in {
 340   def V6_vL32Ub_pi : T_vload_pi_64B <"$dst = vmemu($src1++#$src2)">,
 341                      V6_vL32Ub_pi_enc;
 342   // 128B
 343   def V6_vL32Ub_pi_128B : T_vload_pi_128B <"$dst = vmemu($src1++#$src2)">,
 344                           V6_vL32Ub_pi_128B_enc;
 345 }
 346
 347 let isCVLoad = 1, Itinerary = CVI_VM_LD, Type = TypeCVI_VM_LD in {
 348   def V6_vL32b_cur_pi    : T_vload_pi_64B <"$dst.cur = vmem($src1++#$src2)">,
 349                            V6_vL32b_cur_pi_enc;
 350   def V6_vL32b_nt_cur_pi : T_vload_pi_64B <"$dst.cur = vmem($src1++#$src2):nt">,
 351                            V6_vL32b_nt_cur_pi_enc;
 352   // 128B
 353   def V6_vL32b_cur_pi_128B    : T_vload_pi_128B
 354                                 <"$dst.cur = vmem($src1++#$src2)">,
 355                                 V6_vL32b_cur_pi_128B_enc;
 356   def V6_vL32b_nt_cur_pi_128B : T_vload_pi_128B
 357                                 <"$dst.cur = vmem($src1++#$src2):nt">,
 358                                 V6_vL32b_nt_cur_pi_128B_enc;
 359 }
 360
 361 let Itinerary = CVI_VM_TMP_LD, Type = TypeCVI_VM_TMP_LD in {
 362   def V6_vL32b_tmp_pi    : T_vload_pi_64B <"$dst.tmp = vmem($src1++#$src2)">,
 363                            V6_vL32b_tmp_pi_enc;
 364   def V6_vL32b_nt_tmp_pi : T_vload_pi_64B <"$dst.tmp = vmem($src1++#$src2):nt">,
 365                            V6_vL32b_nt_tmp_pi_enc;
 366   //128B
 367   def V6_vL32b_tmp_pi_128B    : T_vload_pi_128B
 368                                 <"$dst.tmp = vmem($src1++#$src2)">,
 369                                 V6_vL32b_tmp_pi_128B_enc;
 370   def V6_vL32b_nt_tmp_pi_128B : T_vload_pi_128B
 371                                 <"$dst.tmp = vmem($src1++#$src2):nt">,
 372                                 V6_vL32b_nt_tmp_pi_128B_enc;
 373 }
 374
 375 //===----------------------------------------------------------------------===//
 376 // Post increment vector stores with immediate offset.
 377 //===----------------------------------------------------------------------===//
 378 let addrMode = PostInc, isPredicable = 1 in
 379 class T_vstore_pi <string mnemonic, string baseOp, Operand ImmOp,
 380                    RegisterClass RC, bit isNT>
 381   : V6_STInst <(outs IntRegs:$_dst_),
 382                (ins IntRegs:$src1, ImmOp:$src2, RC:$src3),
 383     mnemonic#"($src1++#$src2)"#!if(isNT, ":nt", "")#" = $src3", [],
 384     "$src1 = $_dst_">, NewValueRel {
 385   let BaseOpcode = baseOp;
 386 }
 387
 388 let accessSize = Vector64Access in
 389 class T_vstore_pi_64B <string mnemonic, string baseOp, bit isNT = 0>
 390   : T_vstore_pi <mnemonic, baseOp, s3_6Imm, VectorRegs, isNT>;
 391
 392 let isCodeGenOnly = 1, accessSize = Vector128Access in
 393 class T_vstore_pi_128B <string mnemonic, string baseOp, bit isNT = 0>
 394   : T_vstore_pi <mnemonic, baseOp#"128B", s3_7Imm, VectorRegs128B, isNT>;
 395
 396 let isNVStorable = 1 in {
 397   def V6_vS32b_pi      : T_vstore_pi_64B <"vmem", "vS32b_pi">, V6_vS32b_pi_enc;
 398   def V6_vS32b_pi_128B : T_vstore_pi_128B <"vmem", "vS32b_pi">,
 399                          V6_vS32b_pi_128B_enc;
 400 }
 401
 402 let isNVStorable = 1 , isNonTemporal = 1  in {
 403   def V6_vS32b_nt_pi      : T_vstore_pi_64B <"vmem", "vS32b_pi", 1>,
 404                             V6_vS32b_nt_pi_enc;
 405   def V6_vS32b_nt_pi_128B : T_vstore_pi_128B <"vmem", "vS32b_pi", 1>,
 406                             V6_vS32b_nt_pi_128B_enc;
 407 }
 408
 409
 410 let Itinerary = CVI_VM_STU, Type = TypeCVI_VM_STU in {
 411   def V6_vS32Ub_pi      : T_vstore_pi_64B <"vmemu", "vS32Ub_pi">,
 412                           V6_vS32Ub_pi_enc;
 413   def V6_vS32Ub_pi_128B : T_vstore_pi_128B <"vmemu", "vS32Ub_pi">,
 414                           V6_vS32Ub_pi_128B_enc;
 415 }
 416
 417 //===----------------------------------------------------------------------===//
 418 // Post increment unconditional .new vector stores with immediate offset.
 419 //===----------------------------------------------------------------------===//
 420 let addrMode = PostInc, isNVStore = 1 in
 421 let Itinerary = CVI_VM_NEW_ST, Type = TypeCVI_VM_NEW_ST, isNewValue = 1,
 422     isPredicable = 1, opNewValue = 3, isNVStore = 1 in
 423 class T_vstore_new_pi <string baseOp, Operand ImmOp, RegisterClass RC, bit isNT>
 424   : V6_STInst <(outs IntRegs:$_dst_),
 425                (ins IntRegs:$src1, ImmOp:$src2, RC:$src3),
 426     "vmem($src1++#$src2)"#!if(isNT, ":nt", "")#" = $src3.new", [],
 427     "$src1 = $_dst_">, NewValueRel {
 428   let BaseOpcode = baseOp;
 429 }
 430
 431 let accessSize = Vector64Access in
 432 class T_vstore_new_pi_64B <string baseOp, bit isNT = 0>
 433   : T_vstore_new_pi <baseOp, s3_6Imm, VectorRegs, isNT>;
 434
 435 let isCodeGenOnly = 1, accessSize = Vector128Access in
 436 class T_vstore_new_pi_128B <string baseOp, bit isNT = 0>
 437   : T_vstore_new_pi <baseOp#"128B", s3_7Imm, VectorRegs128B, isNT>;
 438
 439
 440 def V6_vS32b_new_pi      : T_vstore_new_pi_64B <"vS32b_pi">,
 441                            V6_vS32b_new_pi_enc;
 442 def V6_vS32b_new_pi_128B : T_vstore_new_pi_128B <"vS32b_pi">,
 443                            V6_vS32b_new_pi_128B_enc;
 444
 445 let isNonTemporal = 1 in {
 446   def V6_vS32b_nt_new_pi      : T_vstore_new_pi_64B <"vS32b_pi", 1>,
 447                                 V6_vS32b_nt_new_pi_enc;
 448   def V6_vS32b_nt_new_pi_128B : T_vstore_new_pi_128B <"vS32b_pi", 1>,
 449                                 V6_vS32b_nt_new_pi_128B_enc;
 450 }
 451
 452 //===----------------------------------------------------------------------===//
 453 // Post increment conditional vector stores with immediate offset
 454 //===----------------------------------------------------------------------===//
 455 let isPredicated = 1, addrMode = PostInc in
 456 class T_vstore_pred_pi <string mnemonic, string baseOp, Operand ImmOp,
 457                         RegisterClass RC, bit isPredNot, bit isNT>
 458   : V6_STInst<(outs IntRegs:$_dst_),
 459              (ins PredRegs:$src1, IntRegs:$src2, ImmOp:$src3, RC:$src4),
 460     "if ("#!if(isPredNot, "!", "")#"$src1) "#mnemonic#"($src2++#$src3)"
 461           #!if(isNT, ":nt", "")#" = $src4", [],
 462     "$src2 = $_dst_">, NewValueRel {
 463   let isPredicatedFalse = isPredNot;
 464   let BaseOpcode = baseOp;
 465 }
 466
 467 let accessSize = Vector64Access in
 468 class T_vstore_pred_pi_64B <string mnemonic, string baseOp,
 469                             bit isPredNot = 0, bit isNT = 0>
 470   : T_vstore_pred_pi <mnemonic, baseOp, s3_6Imm, VectorRegs, isPredNot, isNT>;
 471
 472 let isCodeGenOnly = 1, accessSize = Vector128Access in
 473 class T_vstore_pred_pi_128B <string mnemonic, string baseOp,
 474                              bit isPredNot = 0, bit isNT = 0>
 475   : T_vstore_pred_pi <mnemonic, baseOp#"128B", s3_7Imm, VectorRegs128B,
 476                       isPredNot, isNT>;
 477
 478 let isNVStorable = 1 in {
 479   def V6_vS32b_pred_pi     : T_vstore_pred_pi_64B <"vmem", "vS32b_pi">,
 480                              V6_vS32b_pred_pi_enc;
 481   def V6_vS32b_npred_pi    : T_vstore_pred_pi_64B <"vmem", "vS32b_pi", 1>,
 482                              V6_vS32b_npred_pi_enc;
 483   // 128B
 484   def V6_vS32b_pred_pi_128B  : T_vstore_pred_pi_128B <"vmem", "vS32b_pi">,
 485                                V6_vS32b_pred_pi_128B_enc;
 486   def V6_vS32b_npred_pi_128B : T_vstore_pred_pi_128B <"vmem", "vS32b_pi", 1>,
 487                                V6_vS32b_npred_pi_128B_enc;
 488 }
 489 let isNVStorable = 1, isNonTemporal = 1 in {
 490   def V6_vS32b_nt_pred_pi  : T_vstore_pred_pi_64B <"vmem", "vS32b_pi", 0, 1>,
 491                              V6_vS32b_nt_pred_pi_enc;
 492   def V6_vS32b_nt_npred_pi : T_vstore_pred_pi_64B <"vmem", "vS32b_pi", 1, 1>,
 493                              V6_vS32b_nt_npred_pi_enc;
 494   // 128B
 495   def V6_vS32b_nt_pred_pi_128B  : T_vstore_pred_pi_128B
 496                                   <"vmem", "vS32b_pi", 0, 1>,
 497                                   V6_vS32b_nt_pred_pi_128B_enc;
 498   def V6_vS32b_nt_npred_pi_128B : T_vstore_pred_pi_128B
 499                                   <"vmem", "vS32b_pi", 1, 1>,
 500                                   V6_vS32b_nt_npred_pi_128B_enc;
 501 }
 502
 503 let Itinerary = CVI_VM_STU, Type = TypeCVI_VM_STU in {
 504   def V6_vS32Ub_pred_pi  : T_vstore_pred_pi_64B <"vmemu", "vS32Ub_pi">,
 505                            V6_vS32Ub_pred_pi_enc;
 506   def V6_vS32Ub_npred_pi : T_vstore_pred_pi_64B <"vmemu", "vS32Ub_pi", 1>,
 507                            V6_vS32Ub_npred_pi_enc;
 508   // 128B
 509   def V6_vS32Ub_pred_pi_128B  : T_vstore_pred_pi_128B <"vmemu", "vS32Ub_pi">,
 510                                 V6_vS32Ub_pred_pi_128B_enc;
 511   def V6_vS32Ub_npred_pi_128B : T_vstore_pred_pi_128B <"vmemu", "vS32Ub_pi", 1>,
 512                                 V6_vS32Ub_npred_pi_128B_enc;
 513 }
 514
 515 //===----------------------------------------------------------------------===//
 516 // Post increment vector stores with immediate offset - byte-enabled aligned
 517 //===----------------------------------------------------------------------===//
 518 let addrMode = PostInc in
 519 class T_vstore_qpred_pi <Operand ImmOp, RegisterClass RC, bit isPredNot = 0,
 520                          bit isNT = 0>
 521   : V6_STInst <(outs IntRegs:$_dst_),
 522                (ins VecPredRegs:$src1, IntRegs:$src2, ImmOp:$src3, RC:$src4),
 523     "if ("#!if(isPredNot, "!", "")#"$src1) vmem($src2++#$src3)"
 524           #!if(isNT, ":nt", "")#" = $src4", [],
 525     "$src2 = $_dst_">;
 526
 527 let accessSize = Vector64Access in
 528 class T_vstore_qpred_pi_64B <bit isPredNot = 0, bit isNT = 0>
 529   : T_vstore_qpred_pi <s3_6Imm, VectorRegs, isPredNot, isNT>;
 530
 531 let isCodeGenOnly = 1, accessSize = Vector128Access in
 532 class T_vstore_qpred_pi_128B <bit isPredNot = 0, bit isNT = 0>
 533   : T_vstore_qpred_pi <s3_7Imm, VectorRegs128B, isPredNot, isNT>;
 534
 535 def V6_vS32b_qpred_pi  : T_vstore_qpred_pi_64B, V6_vS32b_qpred_pi_enc;
 536 def V6_vS32b_nqpred_pi : T_vstore_qpred_pi_64B <1>, V6_vS32b_nqpred_pi_enc;
 537 // 128B
 538 def V6_vS32b_qpred_pi_128B  : T_vstore_qpred_pi_128B,
 539                               V6_vS32b_qpred_pi_128B_enc;
 540 def V6_vS32b_nqpred_pi_128B : T_vstore_qpred_pi_128B<1>,
 541                               V6_vS32b_nqpred_pi_128B_enc;
 542
 543 let isNonTemporal = 1 in {
 544   def V6_vS32b_nt_qpred_pi  : T_vstore_qpred_pi_64B <0, 1>,
 545                               V6_vS32b_nt_qpred_pi_enc;
 546   def V6_vS32b_nt_nqpred_pi : T_vstore_qpred_pi_64B <1, 1>,
 547                               V6_vS32b_nt_nqpred_pi_enc;
 548   // 128B
 549   def V6_vS32b_nt_qpred_pi_128B  : T_vstore_qpred_pi_128B<0, 1>,
 550                                    V6_vS32b_nt_qpred_pi_128B_enc;
 551   def V6_vS32b_nt_nqpred_pi_128B : T_vstore_qpred_pi_128B<1, 1>,
 552                                    V6_vS32b_nt_nqpred_pi_128B_enc;
 553 }
 554
 555 //===----------------------------------------------------------------------===//
 556 // Post increment conditional .new vector stores with immediate offset
 557 //===----------------------------------------------------------------------===//
 558 let Itinerary = CVI_VM_NEW_ST, Type = TypeCVI_VM_NEW_ST, isPredicated = 1,
 559     isNewValue = 1, opNewValue = 4, addrMode = PostInc, isNVStore = 1 in
 560 class T_vstore_new_pred_pi <string baseOp, Operand ImmOp, RegisterClass RC,
 561                             bit isPredNot, bit isNT>
 562   : V6_STInst <(outs IntRegs:$_dst_),
 563                (ins PredRegs:$src1, IntRegs:$src2, ImmOp:$src3, RC:$src4),
 564     "if("#!if(isPredNot, "!", "")#"$src1) vmem($src2++#$src3)"
 565          #!if(isNT, ":nt", "")#" = $src4.new", [],
 566     "$src2 = $_dst_"> , NewValueRel {
 567   let isPredicatedFalse = isPredNot;
 568   let BaseOpcode = baseOp;
 569 }
 570
 571 let accessSize = Vector64Access in
 572 class T_vstore_new_pred_pi_64B <string baseOp, bit isPredNot = 0, bit isNT = 0>
 573   : T_vstore_new_pred_pi <baseOp, s3_6Imm, VectorRegs, isPredNot, isNT>;
 574
 575 let isCodeGenOnly = 1, accessSize = Vector128Access in
 576 class T_vstore_new_pred_pi_128B <string baseOp, bit isPredNot = 0, bit isNT = 0>
 577   : T_vstore_new_pred_pi <baseOp#"128B", s3_7Imm, VectorRegs128B,
 578                           isPredNot, isNT>;
 579
 580 def V6_vS32b_new_pred_pi     : T_vstore_new_pred_pi_64B <"vS32b_pi">,
 581                                V6_vS32b_new_pred_pi_enc;
 582 def V6_vS32b_new_npred_pi    : T_vstore_new_pred_pi_64B <"vS32b_pi", 1>,
 583                                V6_vS32b_new_npred_pi_enc;
 584 // 128B
 585 def V6_vS32b_new_pred_pi_128B    : T_vstore_new_pred_pi_128B <"vS32b_pi">,
 586                                    V6_vS32b_new_pred_pi_128B_enc;
 587 def V6_vS32b_new_npred_pi_128B   : T_vstore_new_pred_pi_128B <"vS32b_pi", 1>,
 588                                    V6_vS32b_new_npred_pi_128B_enc;
 589 let isNonTemporal = 1 in {
 590   def V6_vS32b_nt_new_pred_pi  : T_vstore_new_pred_pi_64B <"vS32b_pi", 0, 1>,
 591                                  V6_vS32b_nt_new_pred_pi_enc;
 592   def V6_vS32b_nt_new_npred_pi : T_vstore_new_pred_pi_64B <"vS32b_pi", 1, 1>,
 593                                  V6_vS32b_nt_new_npred_pi_enc;
 594   // 128B
 595   def V6_vS32b_nt_new_pred_pi_128B : T_vstore_new_pred_pi_128B
 596                                      <"vS32b_pi", 0, 1>,
 597                                      V6_vS32b_nt_new_pred_pi_128B_enc;
 598   def V6_vS32b_nt_new_npred_pi_128B : T_vstore_new_pred_pi_128B
 599                                       <"vS32b_pi", 1, 1>,
 600                                       V6_vS32b_nt_new_npred_pi_128B_enc;
 601 }
 602
 603 //===----------------------------------------------------------------------===//
 604 // Post increment vector loads with register offset
 605 //===----------------------------------------------------------------------===//
 606 let hasNewValue = 1 in
 607 class T_vload_ppu<string asmStr>
 608   : V6_LDInst <(outs VectorRegs:$dst, IntRegs:$_dst_),
 609                (ins IntRegs:$src1, ModRegs:$src2), asmStr, [],
 610     "$src1 = $_dst_">, NewValueRel;
 611
 612 let isCVLoadable = 1 in {
 613   def V6_vL32b_ppu    : T_vload_ppu <"$dst = vmem($src1++$src2)">,
 614                         V6_vL32b_ppu_enc;
 615   def V6_vL32b_nt_ppu : T_vload_ppu <"$dst = vmem($src1++$src2):nt">,
 616                         V6_vL32b_nt_ppu_enc;
 617 }
 618
 619 let Itinerary = CVI_VM_VP_LDU, Type = TypeCVI_VM_VP_LDU in
 620 def V6_vL32Ub_ppu : T_vload_ppu <"$dst = vmemu($src1++$src2)">,
 621                      V6_vL32Ub_ppu_enc;
 622
 623 let isCVLoad = 1, Itinerary = CVI_VM_CUR_LD, Type = TypeCVI_VM_CUR_LD in {
 624   def V6_vL32b_cur_ppu    : T_vload_ppu <"$dst.cur = vmem($src1++$src2)">,
 625                              V6_vL32b_cur_ppu_enc;
 626   def V6_vL32b_nt_cur_ppu : T_vload_ppu <"$dst.cur = vmem($src1++$src2):nt">,
 627                              V6_vL32b_nt_cur_ppu_enc;
 628 }
 629
 630 let Itinerary = CVI_VM_TMP_LD, Type = TypeCVI_VM_TMP_LD in {
 631   def V6_vL32b_tmp_ppu    : T_vload_ppu <"$dst.tmp = vmem($src1++$src2)">,
 632                              V6_vL32b_tmp_ppu_enc;
 633   def V6_vL32b_nt_tmp_ppu : T_vload_ppu <"$dst.tmp = vmem($src1++$src2):nt">,
 634                              V6_vL32b_nt_tmp_ppu_enc;
 635 }
 636
 637 //===----------------------------------------------------------------------===//
 638 // Post increment vector stores with register offset
 639 //===----------------------------------------------------------------------===//
 640 let isPredicable = 1 in
 641 class T_vstore_ppu <string mnemonic, bit isNT = 0>
 642   : V6_STInst <(outs IntRegs:$_dst_),
 643                (ins IntRegs:$src1, ModRegs:$src2, VectorRegs:$src3),
 644     mnemonic#"($src1++$src2)"#!if(isNT, ":nt", "")#" = $src3", [],
 645     "$src1 = $_dst_">, NewValueRel;
 646
 647 let isNVStorable = 1, BaseOpcode = "vS32b_ppu" in {
 648   def V6_vS32b_ppu    : T_vstore_ppu <"vmem">,
 649                         V6_vS32b_ppu_enc;
 650   let isNonTemporal = 1, BaseOpcode = "vS32b_ppu" in
 651   def V6_vS32b_nt_ppu : T_vstore_ppu <"vmem", 1>,
 652                         V6_vS32b_nt_ppu_enc;
 653 }
 654
 655 let BaseOpcode = "vS32Ub_ppu", Itinerary = CVI_VM_STU, Type = TypeCVI_VM_STU in
 656 def V6_vS32Ub_ppu   : T_vstore_ppu <"vmemu">, V6_vS32Ub_ppu_enc;
 657
 658 //===----------------------------------------------------------------------===//
 659 // Post increment .new vector stores with register offset
 660 //===----------------------------------------------------------------------===//
 661 let Itinerary = CVI_VM_NEW_ST, Type = TypeCVI_VM_NEW_ST, isNewValue = 1,
 662     isPredicable = 1, opNewValue = 3, isNVStore = 1 in
 663 class T_vstore_new_ppu <bit isNT = 0>
 664   : V6_STInst <(outs IntRegs:$_dst_),
 665                (ins IntRegs:$src1, ModRegs:$src2, VectorRegs:$src3),
 666     "vmem($src1++$src2)"#!if(isNT, ":nt", "")#" = $src3.new", [],
 667     "$src1 = $_dst_">, NewValueRel;
 668
 669 let BaseOpcode = "vS32b_ppu" in
 670 def V6_vS32b_new_ppu    : T_vstore_new_ppu, V6_vS32b_new_ppu_enc;
 671
 672 let BaseOpcode = "vS32b_ppu", isNonTemporal = 1 in
 673 def V6_vS32b_nt_new_ppu : T_vstore_new_ppu<1>, V6_vS32b_nt_new_ppu_enc;
 674
 675 //===----------------------------------------------------------------------===//
 676 // Post increment conditional .new vector stores with register offset
 677 //===----------------------------------------------------------------------===//
 678 let isPredicated = 1 in
 679 class T_vstore_pred_ppu <string mnemonic, bit isPredNot = 0, bit isNT = 0>
 680   : V6_STInst<(outs IntRegs:$_dst_),
 681            (ins PredRegs:$src1, IntRegs:$src2, ModRegs:$src3, VectorRegs:$src4),
 682     "if ("#!if(isPredNot, "!", "")#"$src1) "#mnemonic#"($src2++$src3)"
 683           #!if(isNT, ":nt", "")#" = $src4", [],
 684     "$src2 = $_dst_">, NewValueRel {
 685   let isPredicatedFalse = isPredNot;
 686 }
 687
 688 let isNVStorable = 1, BaseOpcode = "vS32b_ppu" in {
 689   def V6_vS32b_pred_ppu : T_vstore_pred_ppu<"vmem">, V6_vS32b_pred_ppu_enc;
 690   def V6_vS32b_npred_ppu: T_vstore_pred_ppu<"vmem", 1>, V6_vS32b_npred_ppu_enc;
 691 }
 692
 693 let isNVStorable = 1, BaseOpcode = "vS32b_ppu", isNonTemporal = 1 in {
 694   def V6_vS32b_nt_pred_ppu  : T_vstore_pred_ppu <"vmem", 0, 1>,
 695                               V6_vS32b_nt_pred_ppu_enc;
 696   def V6_vS32b_nt_npred_ppu : T_vstore_pred_ppu <"vmem", 1, 1>,
 697                               V6_vS32b_nt_npred_ppu_enc;
 698 }
 699
 700 let BaseOpcode = "vS32Ub_ppu", Itinerary = CVI_VM_STU,
 701     Type = TypeCVI_VM_STU in {
 702   def V6_vS32Ub_pred_ppu  : T_vstore_pred_ppu <"vmemu">,
 703                             V6_vS32Ub_pred_ppu_enc;
 704   def V6_vS32Ub_npred_ppu : T_vstore_pred_ppu <"vmemu", 1>,
 705                             V6_vS32Ub_npred_ppu_enc;
 706 }
 707
 708 //===----------------------------------------------------------------------===//
 709 // Post increment vector stores with register offset - byte-enabled aligned
 710 //===----------------------------------------------------------------------===//
 711 class T_vstore_qpred_ppu <bit isPredNot = 0, bit isNT = 0>
 712   : V6_STInst <(outs IntRegs:$_dst_),
 713         (ins VecPredRegs:$src1, IntRegs:$src2, ModRegs:$src3, VectorRegs:$src4),
 714     "if ("#!if(isPredNot, "!", "")#"$src1) vmem($src2++$src3)"
 715           #!if(isNT, ":nt", "")#" = $src4", [],
 716     "$src2 = $_dst_">, NewValueRel;
 717
 718 def V6_vS32b_qpred_ppu  : T_vstore_qpred_ppu, V6_vS32b_qpred_ppu_enc;
 719 def V6_vS32b_nqpred_ppu : T_vstore_qpred_ppu<1>, V6_vS32b_nqpred_ppu_enc;
 720 def V6_vS32b_nt_qpred_ppu  : T_vstore_qpred_ppu<0, 1>,
 721                              V6_vS32b_nt_qpred_ppu_enc;
 722 def V6_vS32b_nt_nqpred_ppu : T_vstore_qpred_ppu<1, 1>,
 723                              V6_vS32b_nt_nqpred_ppu_enc;
 724
 725 //===----------------------------------------------------------------------===//
 726 // Post increment conditional .new vector stores with register offset
 727 //===----------------------------------------------------------------------===//
 728 let Itinerary = CVI_VM_NEW_ST, Type = TypeCVI_VM_NEW_ST, isPredicated = 1,
 729     isNewValue = 1, opNewValue = 4, isNVStore = 1 in
 730 class T_vstore_new_pred_ppu <bit isPredNot = 0, bit isNT = 0>
 731   : V6_STInst <(outs IntRegs:$_dst_),
 732            (ins PredRegs:$src1, IntRegs:$src2, ModRegs:$src3, VectorRegs:$src4),
 733     "if("#!if(isPredNot, "!", "")#"$src1) vmem($src2++$src3)"
 734          #!if(isNT, ":nt", "")#" = $src4.new", [],
 735     "$src2 = $_dst_">, NewValueRel {
 736   let isPredicatedFalse = isPredNot;
 737 }
 738
 739 let BaseOpcode = "vS32b_ppu" in {
 740   def V6_vS32b_new_pred_ppu  : T_vstore_new_pred_ppu,
 741                                V6_vS32b_new_pred_ppu_enc;
 742   def V6_vS32b_new_npred_ppu : T_vstore_new_pred_ppu<1>,
 743                                V6_vS32b_new_npred_ppu_enc;
 744 }
 745
 746 let BaseOpcode = "vS32b_ppu", isNonTemporal = 1 in {
 747 def V6_vS32b_nt_new_pred_ppu :  T_vstore_new_pred_ppu<0, 1>,
 748                                 V6_vS32b_nt_new_pred_ppu_enc;
 749 def V6_vS32b_nt_new_npred_ppu : T_vstore_new_pred_ppu<1, 1>,
 750                                 V6_vS32b_nt_new_npred_ppu_enc;
 751 }
 752
 753
 754 // Vector load/store pseudos
 755
 756 let isPseudo = 1, isCodeGenOnly = 1, validSubTargets = HasV60SubT in
 757 class STrivv_template<RegisterClass RC>
 758   : V6_STInst<(outs), (ins IntRegs:$addr, s32_0Imm:$off, RC:$src), "", []>;
 759
 760 def PS_vstorerw_ai: STrivv_template<VecDblRegs>,
 761       Requires<[HasV60T,UseHVXSgl]>;
 762 def PS_vstorerwu_ai: STrivv_template<VecDblRegs>,
 763       Requires<[HasV60T,UseHVXSgl]>;
 764 def PS_vstorerw_ai_128B: STrivv_template<VecDblRegs128B>,
 765       Requires<[HasV60T,UseHVXDbl]>;
 766 def PS_vstorerwu_ai_128B: STrivv_template<VecDblRegs128B>,
 767       Requires<[HasV60T,UseHVXDbl]>;
 768
 769
 770 let isPseudo = 1, isCodeGenOnly = 1, validSubTargets = HasV60SubT in
 771 class LDrivv_template<RegisterClass RC>
 772   : V6_LDInst<(outs RC:$dst), (ins IntRegs:$addr, s32_0Imm:$off), "", []>;
 773
 774 def PS_vloadrw_ai: LDrivv_template<VecDblRegs>,
 775       Requires<[HasV60T,UseHVXSgl]>;
 776 def PS_vloadrwu_ai: LDrivv_template<VecDblRegs>,
 777       Requires<[HasV60T,UseHVXSgl]>;
 778 def PS_vloadrw_ai_128B: LDrivv_template<VecDblRegs128B>,
 779       Requires<[HasV60T,UseHVXDbl]>;
 780 def PS_vloadrwu_ai_128B: LDrivv_template<VecDblRegs128B>,
 781       Requires<[HasV60T,UseHVXDbl]>;
 782
 783 // Store vector predicate pseudo.
 784 let isExtendable = 1, opExtendable = 1, isExtentSigned = 1, opExtentBits = 13,
 785     isCodeGenOnly = 1, isPseudo = 1, mayStore = 1, hasSideEffects = 0 in {
 786   def PS_vstorerq_ai : STInst<(outs),
 787               (ins IntRegs:$base, s32_0Imm:$offset, VecPredRegs:$src1),
 788               ".error \"should not emit\"", []>,
 789               Requires<[HasV60T,UseHVXSgl]>;
 790   def PS_vstorerq_ai_128B : STInst<(outs),
 791               (ins IntRegs:$base, s32_0Imm:$offset, VecPredRegs128B:$src1),
 792               ".error \"should not emit\"", []>,
 793               Requires<[HasV60T,UseHVXDbl]>;
 794 }
 795
 796 // Load vector predicate pseudo.
 797 let isExtendable = 1, opExtendable = 2, isExtentSigned = 1, opExtentBits = 13,
 798     opExtentAlign = 2, isCodeGenOnly = 1, isPseudo = 1, hasSideEffects = 0 in {
 799   def PS_vloadrq_ai : LDInst<(outs VecPredRegs:$dst),
 800               (ins IntRegs:$base, s32_0Imm:$offset),
 801               ".error \"should not emit\"", []>,
 802               Requires<[HasV60T,UseHVXSgl]>;
 803   def PS_vloadrq_ai_128B : LDInst<(outs VecPredRegs128B:$dst),
 804               (ins IntRegs:$base, s32_0Imm:$offset),
 805               ".error \"should not emit\"", []>,
 806               Requires<[HasV60T,UseHVXDbl]>;
 807 }
 808
 809 class VSELInst<dag outs, dag ins, string asmstr, list<dag> pattern = [],
 810               string cstr = "", InstrItinClass itin = CVI_VA_DV,
 811               IType type = TypeCVI_VA_DV>
 812   : InstHexagon<outs, ins, asmstr, pattern, cstr, itin, type>;
 813
 814 let isCodeGenOnly = 1, isPseudo = 1, hasSideEffects = 0 in {
 815   def PS_vselect: VSELInst<(outs VectorRegs:$dst),
 816         (ins PredRegs:$src1, VectorRegs:$src2, VectorRegs:$src3), "", []>,
 817         Requires<[HasV60T,UseHVXSgl]>;
 818   def PS_vselect_128B: VSELInst<(outs VectorRegs128B:$dst),
 819         (ins PredRegs:$src1, VectorRegs128B:$src2, VectorRegs128B:$src3),
 820         "", []>, Requires<[HasV60T,UseHVXDbl]>;
 821   def PS_wselect: VSELInst<(outs VecDblRegs:$dst),
 822         (ins PredRegs:$src1, VecDblRegs:$src2, VecDblRegs:$src3), "", []>,
 823         Requires<[HasV60T,UseHVXSgl]>;
 824   def PS_wselect_128B: VSELInst<(outs VecDblRegs128B:$dst),
 825         (ins PredRegs:$src1, VecDblRegs128B:$src2, VecDblRegs128B:$src3),
 826         "", []>, Requires<[HasV60T,UseHVXDbl]>;
 827 }
 828
 829 let hasNewValue = 1 in
 830 class T_vmpy <string asmString, RegisterClass RCout, RegisterClass RCin>
 831   : CVI_VX_DV_Resource1<(outs RCout:$dst), (ins RCin:$src1, IntRegs:$src2),
 832     asmString >;
 833
 834 multiclass T_vmpy <string asmString, RegisterClass RCout,
 835                         RegisterClass RCin> {
 836   def NAME : T_vmpy <asmString, RCout, RCin>;
 837   let isCodeGenOnly = 1 in
 838   def NAME#_128B : T_vmpy <asmString, !cast<RegisterClass>(RCout#"128B"),
 839                                       !cast<RegisterClass>(RCin#"128B")>;
 840 }
 841
 842 multiclass T_vmpy_VV <string asmString>:
 843   T_vmpy <asmString, VectorRegs, VectorRegs>;
 844
 845 multiclass T_vmpy_WW <string asmString>:
 846   T_vmpy <asmString, VecDblRegs, VecDblRegs>;
 847
 848 multiclass T_vmpy_VW <string asmString>:
 849   T_vmpy <asmString, VectorRegs, VecDblRegs>;
 850
 851 multiclass T_vmpy_WV <string asmString>:
 852   T_vmpy <asmString, VecDblRegs, VectorRegs>;
 853
 854 defm V6_vtmpyb   :T_vmpy_WW<"$dst.h = vtmpy($src1.b,$src2.b)">, V6_vtmpyb_enc;
 855 defm V6_vtmpybus :T_vmpy_WW<"$dst.h = vtmpy($src1.ub,$src2.b)">, V6_vtmpybus_enc;
 856 defm V6_vdsaduh  :T_vmpy_WW<"$dst.uw = vdsad($src1.uh,$src2.uh)">, V6_vdsaduh_enc;
 857 defm V6_vmpybus  :T_vmpy_WV<"$dst.h = vmpy($src1.ub,$src2.b)">, V6_vmpybus_enc;
 858 defm V6_vmpabus  :T_vmpy_WW<"$dst.h = vmpa($src1.ub,$src2.b)">, V6_vmpabus_enc;
 859 defm V6_vmpahb   :T_vmpy_WW<"$dst.w = vmpa($src1.h,$src2.b)">, V6_vmpahb_enc;
 860 defm V6_vmpyh    :T_vmpy_WV<"$dst.w = vmpy($src1.h,$src2.h)">, V6_vmpyh_enc;
 861 defm V6_vmpyuh   :T_vmpy_WV<"$dst.uw = vmpy($src1.uh,$src2.uh)">, V6_vmpyuh_enc;
 862 defm V6_vmpyiwh  :T_vmpy_VV<"$dst.w = vmpyi($src1.w,$src2.h)">, V6_vmpyiwh_enc;
 863 defm V6_vtmpyhb  :T_vmpy_WW<"$dst.w = vtmpy($src1.h,$src2.b)">, V6_vtmpyhb_enc;
 864 defm V6_vmpyub   :T_vmpy_WV<"$dst.uh = vmpy($src1.ub,$src2.ub)">, V6_vmpyub_enc;
 865
 866 let Itinerary = CVI_VX_LONG, Type = TypeCVI_VX in
 867 defm V6_vmpyihb  :T_vmpy_VV<"$dst.h = vmpyi($src1.h,$src2.b)">, V6_vmpyihb_enc;
 868
 869 defm V6_vdmpybus_dv :
 870      T_vmpy_WW <"$dst.h = vdmpy($src1.ub,$src2.b)">, V6_vdmpybus_dv_enc;
 871 defm V6_vdmpyhsusat :
 872      T_vmpy_VV <"$dst.w = vdmpy($src1.h,$src2.uh):sat">, V6_vdmpyhsusat_enc;
 873 defm V6_vdmpyhsuisat :
 874      T_vmpy_VW <"$dst.w = vdmpy($src1.h,$src2.uh,#1):sat">, V6_vdmpyhsuisat_enc;
 875 defm V6_vdmpyhsat :
 876      T_vmpy_VV <"$dst.w = vdmpy($src1.h,$src2.h):sat">, V6_vdmpyhsat_enc;
 877 defm V6_vdmpyhisat :
 878      T_vmpy_VW <"$dst.w = vdmpy($src1.h,$src2.h):sat">, V6_vdmpyhisat_enc;
 879 defm V6_vdmpyhb_dv :
 880      T_vmpy_WW <"$dst.w = vdmpy($src1.h,$src2.b)">, V6_vdmpyhb_dv_enc;
 881 defm V6_vmpyhss :
 882      T_vmpy_VV <"$dst.h = vmpy($src1.h,$src2.h):<<1:sat">, V6_vmpyhss_enc;
 883 defm V6_vmpyhsrs :
 884      T_vmpy_VV <"$dst.h = vmpy($src1.h,$src2.h):<<1:rnd:sat">, V6_vmpyhsrs_enc;
 885
 886 let Itinerary = CVI_VP, Type = TypeCVI_VP in
 887 defm V6_vror : T_vmpy_VV <"$dst = vror($src1,$src2)">, V6_vror_enc;
 888
 889 let Itinerary = CVI_VX, Type = TypeCVI_VX in {
 890 defm V6_vdmpyhb  : T_vmpy_VV<"$dst.w = vdmpy($src1.h,$src2.b)">, V6_vdmpyhb_enc;
 891 defm V6_vrmpybus : T_vmpy_VV<"$dst.w = vrmpy($src1.ub,$src2.b)">, V6_vrmpybus_enc;
 892 defm V6_vdmpybus : T_vmpy_VV<"$dst.h = vdmpy($src1.ub,$src2.b)">, V6_vdmpybus_enc;
 893 defm V6_vmpyiwb  : T_vmpy_VV<"$dst.w = vmpyi($src1.w,$src2.b)">, V6_vmpyiwb_enc;
 894 defm V6_vrmpyub : T_vmpy_VV<"$dst.uw = vrmpy($src1.ub,$src2.ub)">, V6_vrmpyub_enc;
 895 }
 896
 897 let Itinerary = CVI_VS, Type = TypeCVI_VS in {
 898 defm V6_vasrw  : T_vmpy_VV <"$dst.w = vasr($src1.w,$src2)">, V6_vasrw_enc;
 899 defm V6_vasrh  : T_vmpy_VV <"$dst.h = vasr($src1.h,$src2)">, V6_vasrh_enc;
 900 defm V6_vaslw  : T_vmpy_VV <"$dst.w = vasl($src1.w,$src2)">, V6_vaslw_enc;
 901 defm V6_vaslh  : T_vmpy_VV <"$dst.h = vasl($src1.h,$src2)">, V6_vaslh_enc;
 902 defm V6_vlsrw  : T_vmpy_VV <"$dst.uw = vlsr($src1.uw,$src2)">, V6_vlsrw_enc;
 903 defm V6_vlsrh  : T_vmpy_VV <"$dst.uh = vlsr($src1.uh,$src2)">, V6_vlsrh_enc;
 904 }
 905
 906 let hasNewValue = 1 in
 907 class T_HVX_alu <string asmString, InstrItinClass itin,
 908                  RegisterClass RCout, RegisterClass RCin>
 909   : CVI_VA_Resource1 <(outs RCout:$dst), (ins RCin:$src1, RCin:$src2),
 910     asmString >{
 911   let Itinerary = itin;
 912   let Type = !cast<IType>("Type"#itin);
 913 }
 914
 915 multiclass T_HVX_alu <string asmString, RegisterClass RCout,
 916            RegisterClass RCin, InstrItinClass itin> {
 917   def NAME : T_HVX_alu <asmString, itin, RCout, RCin>;
 918   let isCodeGenOnly = 1 in
 919   def NAME#_128B : T_HVX_alu <asmString, itin,
 920                               !cast<RegisterClass>(RCout#"128B"),
 921                               !cast<RegisterClass>(RCin#"128B")>;
 922 }
 923
 924 multiclass T_HVX_alu_VV <string asmString>:
 925   T_HVX_alu <asmString, VectorRegs, VectorRegs, CVI_VA>;
 926
 927 multiclass T_HVX_alu_WW <string asmString>:
 928   T_HVX_alu <asmString, VecDblRegs, VecDblRegs, CVI_VA_DV>;
 929
 930 multiclass T_HVX_alu_WV <string asmString>:
 931   T_HVX_alu <asmString, VecDblRegs, VectorRegs, CVI_VX_DV>;
 932
 933
 934 let Itinerary  =  CVI_VX, Type  =  TypeCVI_VX in {
 935 defm V6_vrmpyubv :
 936      T_HVX_alu_VV <"$dst.uw = vrmpy($src1.ub,$src2.ub)">, V6_vrmpyubv_enc;
 937 defm V6_vrmpybv :
 938      T_HVX_alu_VV <"$dst.w = vrmpy($src1.b,$src2.b)">, V6_vrmpybv_enc;
 939 defm V6_vrmpybusv :
 940      T_HVX_alu_VV <"$dst.w = vrmpy($src1.ub,$src2.b)">, V6_vrmpybusv_enc;
 941 defm V6_vabsdiffub :
 942      T_HVX_alu_VV <"$dst.ub = vabsdiff($src1.ub,$src2.ub)">, V6_vabsdiffub_enc;
 943 defm V6_vabsdiffh :
 944      T_HVX_alu_VV <"$dst.uh = vabsdiff($src1.h,$src2.h)">, V6_vabsdiffh_enc;
 945 defm V6_vabsdiffuh :
 946      T_HVX_alu_VV <"$dst.uh = vabsdiff($src1.uh,$src2.uh)">, V6_vabsdiffuh_enc;
 947 defm V6_vabsdiffw :
 948      T_HVX_alu_VV <"$dst.uw = vabsdiff($src1.w,$src2.w)">, V6_vabsdiffw_enc;
 949 }
 950
 951 let Itinerary = CVI_VX_DV, Type = TypeCVI_VX_DV in {
 952 defm V6_vdmpyhvsat :
 953      T_HVX_alu_VV <"$dst.w = vdmpy($src1.h,$src2.h):sat">, V6_vdmpyhvsat_enc;
 954 defm V6_vmpyhvsrs :
 955      T_HVX_alu_VV<"$dst.h = vmpy($src1.h,$src2.h):<<1:rnd:sat">, V6_vmpyhvsrs_enc;
 956 defm V6_vmpyih :
 957      T_HVX_alu_VV <"$dst.h = vmpyi($src1.h,$src2.h)">, V6_vmpyih_enc;
 958 }
 959
 960 defm V6_vand :
 961      T_HVX_alu_VV <"$dst = vand($src1,$src2)">, V6_vand_enc;
 962 defm V6_vor :
 963      T_HVX_alu_VV <"$dst = vor($src1,$src2)">, V6_vor_enc;
 964 defm V6_vxor :
 965      T_HVX_alu_VV <"$dst = vxor($src1,$src2)">, V6_vxor_enc;
 966 defm V6_vaddw :
 967      T_HVX_alu_VV <"$dst.w = vadd($src1.w,$src2.w)">, V6_vaddw_enc;
 968 defm V6_vaddubsat :
 969      T_HVX_alu_VV <"$dst.ub = vadd($src1.ub,$src2.ub):sat">, V6_vaddubsat_enc;
 970 defm V6_vadduhsat :
 971      T_HVX_alu_VV <"$dst.uh = vadd($src1.uh,$src2.uh):sat">, V6_vadduhsat_enc;
 972 defm V6_vaddhsat :
 973      T_HVX_alu_VV <"$dst.h = vadd($src1.h,$src2.h):sat">, V6_vaddhsat_enc;
 974 defm V6_vaddwsat :
 975      T_HVX_alu_VV <"$dst.w = vadd($src1.w,$src2.w):sat">, V6_vaddwsat_enc;
 976 defm V6_vsubb :
 977      T_HVX_alu_VV <"$dst.b = vsub($src1.b,$src2.b)">, V6_vsubb_enc;
 978 defm V6_vsubh :
 979      T_HVX_alu_VV <"$dst.h = vsub($src1.h,$src2.h)">, V6_vsubh_enc;
 980 defm V6_vsubw :
 981      T_HVX_alu_VV <"$dst.w = vsub($src1.w,$src2.w)">, V6_vsubw_enc;
 982 defm V6_vsububsat :
 983      T_HVX_alu_VV <"$dst.ub = vsub($src1.ub,$src2.ub):sat">, V6_vsububsat_enc;
 984 defm V6_vsubuhsat :
 985      T_HVX_alu_VV <"$dst.uh = vsub($src1.uh,$src2.uh):sat">, V6_vsubuhsat_enc;
 986 defm V6_vsubhsat :
 987      T_HVX_alu_VV <"$dst.h = vsub($src1.h,$src2.h):sat">, V6_vsubhsat_enc;
 988 defm V6_vsubwsat :
 989      T_HVX_alu_VV <"$dst.w = vsub($src1.w,$src2.w):sat">, V6_vsubwsat_enc;
 990 defm V6_vavgub :
 991      T_HVX_alu_VV <"$dst.ub = vavg($src1.ub,$src2.ub)">, V6_vavgub_enc;
 992 defm V6_vavguh :
 993      T_HVX_alu_VV <"$dst.uh = vavg($src1.uh,$src2.uh)">, V6_vavguh_enc;
 994 defm V6_vavgh :
 995      T_HVX_alu_VV <"$dst.h = vavg($src1.h,$src2.h)">, V6_vavgh_enc;
 996 defm V6_vavgw :
 997      T_HVX_alu_VV <"$dst.w = vavg($src1.w,$src2.w)">, V6_vavgw_enc;
 998 defm V6_vnavgub :
 999      T_HVX_alu_VV <"$dst.b = vnavg($src1.ub,$src2.ub)">, V6_vnavgub_enc;
1000 defm V6_vnavgh :
1001      T_HVX_alu_VV <"$dst.h = vnavg($src1.h,$src2.h)">, V6_vnavgh_enc;
1002 defm V6_vnavgw :
1003      T_HVX_alu_VV <"$dst.w = vnavg($src1.w,$src2.w)">, V6_vnavgw_enc;
1004 defm V6_vavgubrnd :
1005      T_HVX_alu_VV <"$dst.ub = vavg($src1.ub,$src2.ub):rnd">, V6_vavgubrnd_enc;
1006 defm V6_vavguhrnd :
1007      T_HVX_alu_VV <"$dst.uh = vavg($src1.uh,$src2.uh):rnd">, V6_vavguhrnd_enc;
1008 defm V6_vavghrnd :
1009      T_HVX_alu_VV <"$dst.h = vavg($src1.h,$src2.h):rnd">, V6_vavghrnd_enc;
1010 defm V6_vavgwrnd :
1011      T_HVX_alu_VV <"$dst.w = vavg($src1.w,$src2.w):rnd">, V6_vavgwrnd_enc;
1012
1013 defm V6_vmpybv :
1014      T_HVX_alu_WV <"$dst.h = vmpy($src1.b,$src2.b)">, V6_vmpybv_enc;
1015 defm V6_vmpyubv :
1016      T_HVX_alu_WV <"$dst.uh = vmpy($src1.ub,$src2.ub)">, V6_vmpyubv_enc;
1017 defm V6_vmpybusv :
1018      T_HVX_alu_WV <"$dst.h = vmpy($src1.ub,$src2.b)">, V6_vmpybusv_enc;
1019 defm V6_vmpyhv :
1020      T_HVX_alu_WV <"$dst.w = vmpy($src1.h,$src2.h)">, V6_vmpyhv_enc;
1021 defm V6_vmpyuhv :
1022      T_HVX_alu_WV <"$dst.uw = vmpy($src1.uh,$src2.uh)">, V6_vmpyuhv_enc;
1023 defm V6_vmpyhus :
1024      T_HVX_alu_WV <"$dst.w = vmpy($src1.h,$src2.uh)">, V6_vmpyhus_enc;
1025 defm V6_vaddubh :
1026      T_HVX_alu_WV <"$dst.h = vadd($src1.ub,$src2.ub)">, V6_vaddubh_enc;
1027 defm V6_vadduhw :
1028      T_HVX_alu_WV <"$dst.w = vadd($src1.uh,$src2.uh)">, V6_vadduhw_enc;
1029 defm V6_vaddhw :
1030      T_HVX_alu_WV <"$dst.w = vadd($src1.h,$src2.h)">, V6_vaddhw_enc;
1031 defm V6_vsububh :
1032      T_HVX_alu_WV <"$dst.h = vsub($src1.ub,$src2.ub)">, V6_vsububh_enc;
1033 defm V6_vsubuhw :
1034      T_HVX_alu_WV <"$dst.w = vsub($src1.uh,$src2.uh)">, V6_vsubuhw_enc;
1035 defm V6_vsubhw :
1036      T_HVX_alu_WV <"$dst.w = vsub($src1.h,$src2.h)">, V6_vsubhw_enc;
1037
1038 defm V6_vaddb_dv :
1039      T_HVX_alu_WW <"$dst.b = vadd($src1.b,$src2.b)">, V6_vaddb_dv_enc;
1040 defm V6_vaddh_dv :
1041      T_HVX_alu_WW <"$dst.h = vadd($src1.h,$src2.h)">, V6_vaddh_dv_enc;
1042 defm V6_vaddw_dv :
1043      T_HVX_alu_WW <"$dst.w = vadd($src1.w,$src2.w)">, V6_vaddw_dv_enc;
1044 defm V6_vaddubsat_dv :
1045      T_HVX_alu_WW <"$dst.ub = vadd($src1.ub,$src2.ub):sat">, V6_vaddubsat_dv_enc;
1046 defm V6_vadduhsat_dv :
1047      T_HVX_alu_WW <"$dst.uh = vadd($src1.uh,$src2.uh):sat">, V6_vadduhsat_dv_enc;
1048 defm V6_vaddhsat_dv :
1049      T_HVX_alu_WW <"$dst.h = vadd($src1.h,$src2.h):sat">, V6_vaddhsat_dv_enc;
1050 defm V6_vaddwsat_dv :
1051      T_HVX_alu_WW <"$dst.w = vadd($src1.w,$src2.w):sat">, V6_vaddwsat_dv_enc;
1052 defm V6_vsubb_dv :
1053      T_HVX_alu_WW <"$dst.b = vsub($src1.b,$src2.b)">, V6_vsubb_dv_enc;
1054 defm V6_vsubh_dv :
1055      T_HVX_alu_WW <"$dst.h = vsub($src1.h,$src2.h)">, V6_vsubh_dv_enc;
1056 defm V6_vsubw_dv :
1057      T_HVX_alu_WW <"$dst.w = vsub($src1.w,$src2.w)">, V6_vsubw_dv_enc;
1058 defm V6_vsububsat_dv :
1059      T_HVX_alu_WW <"$dst.ub = vsub($src1.ub,$src2.ub):sat">, V6_vsububsat_dv_enc;
1060 defm V6_vsubuhsat_dv :
1061      T_HVX_alu_WW <"$dst.uh = vsub($src1.uh,$src2.uh):sat">, V6_vsubuhsat_dv_enc;
1062 defm V6_vsubhsat_dv :
1063      T_HVX_alu_WW <"$dst.h = vsub($src1.h,$src2.h):sat">, V6_vsubhsat_dv_enc;
1064 defm V6_vsubwsat_dv :
1065      T_HVX_alu_WW <"$dst.w = vsub($src1.w,$src2.w):sat">, V6_vsubwsat_dv_enc;
1066
1067 let Itinerary = CVI_VX_DV_LONG, Type = TypeCVI_VX_DV in {
1068 defm V6_vmpabusv :
1069      T_HVX_alu_WW <"$dst.h = vmpa($src1.ub,$src2.b)">, V6_vmpabusv_enc;
1070 defm V6_vmpabuuv :
1071      T_HVX_alu_WW <"$dst.h = vmpa($src1.ub,$src2.ub)">, V6_vmpabuuv_enc;
1072 }
1073
1074 let isAccumulator = 1, hasNewValue = 1 in
1075 class T_HVX_vmpyacc <string asmString, InstrItinClass itin, RegisterClass RCout,
1076                      RegisterClass RCin1, RegisterClass RCin2>
1077   : CVI_VA_Resource1 <(outs RCout:$dst),
1078                       (ins RCout:$_src_, RCin1:$src1, RCin2:$src2), asmString,
1079                       [], "$dst = $_src_" > {
1080   let Itinerary = itin;
1081   let Type = !cast<IType>("Type"#itin);
1082 }
1083
1084 multiclass T_HVX_vmpyacc_both <string asmString, RegisterClass RCout,
1085            RegisterClass RCin1, RegisterClass RCin2, InstrItinClass itin > {
1086   def NAME : T_HVX_vmpyacc <asmString, itin, RCout, RCin1, RCin2>;
1087   let isCodeGenOnly = 1 in
1088   def NAME#_128B : T_HVX_vmpyacc <asmString, itin,
1089                    !cast<RegisterClass>(RCout#"128B"),
1090                    !cast<RegisterClass>(RCin1#"128B"),
1091                    !cast<RegisterClass>(RCin2#
1092                    !if(!eq (!cast<string>(RCin2), "IntRegs"), "", "128B"))>;
1093 }
1094
1095 multiclass T_HVX_vmpyacc_VVR <string asmString>:
1096   T_HVX_vmpyacc_both <asmString, VectorRegs, VectorRegs, IntRegs, CVI_VX>;
1097
1098 multiclass T_HVX_vmpyacc_VWR <string asmString>:
1099   T_HVX_vmpyacc_both <asmString, VectorRegs, VecDblRegs, IntRegs, CVI_VX_DV>;
1100
1101 multiclass T_HVX_vmpyacc_WVR <string asmString>:
1102   T_HVX_vmpyacc_both <asmString, VecDblRegs, VectorRegs, IntRegs, CVI_VX_DV>;
1103
1104 multiclass T_HVX_vmpyacc_WWR <string asmString>:
1105   T_HVX_vmpyacc_both <asmString, VecDblRegs, VecDblRegs, IntRegs, CVI_VX_DV>;
1106
1107 multiclass T_HVX_vmpyacc_VVV <string asmString>:
1108   T_HVX_vmpyacc_both <asmString, VectorRegs, VectorRegs, VectorRegs, CVI_VX_DV>;
1109
1110 multiclass T_HVX_vmpyacc_WVV <string asmString>:
1111   T_HVX_vmpyacc_both <asmString, VecDblRegs, VectorRegs, VectorRegs, CVI_VX_DV>;
1112
1113
1114 defm V6_vtmpyb_acc :
1115      T_HVX_vmpyacc_WWR <"$dst.h += vtmpy($src1.b,$src2.b)">,
1116      V6_vtmpyb_acc_enc;
1117 defm V6_vtmpybus_acc :
1118      T_HVX_vmpyacc_WWR <"$dst.h += vtmpy($src1.ub,$src2.b)">,
1119      V6_vtmpybus_acc_enc;
1120 defm V6_vtmpyhb_acc :
1121      T_HVX_vmpyacc_WWR <"$dst.w += vtmpy($src1.h,$src2.b)">,
1122      V6_vtmpyhb_acc_enc;
1123 defm V6_vdmpyhb_acc :
1124      T_HVX_vmpyacc_VVR <"$dst.w += vdmpy($src1.h,$src2.b)">,
1125      V6_vdmpyhb_acc_enc;
1126 defm V6_vrmpyub_acc :
1127      T_HVX_vmpyacc_VVR <"$dst.uw += vrmpy($src1.ub,$src2.ub)">,
1128      V6_vrmpyub_acc_enc;
1129 defm V6_vrmpybus_acc :
1130      T_HVX_vmpyacc_VVR <"$dst.w += vrmpy($src1.ub,$src2.b)">,
1131      V6_vrmpybus_acc_enc;
1132 defm V6_vdmpybus_acc :
1133      T_HVX_vmpyacc_VVR <"$dst.h += vdmpy($src1.ub,$src2.b)">,
1134      V6_vdmpybus_acc_enc;
1135 defm V6_vdmpybus_dv_acc :
1136      T_HVX_vmpyacc_WWR <"$dst.h += vdmpy($src1.ub,$src2.b)">,
1137      V6_vdmpybus_dv_acc_enc;
1138 defm V6_vdmpyhsuisat_acc :
1139      T_HVX_vmpyacc_VWR <"$dst.w += vdmpy($src1.h,$src2.uh,#1):sat">,
1140      V6_vdmpyhsuisat_acc_enc;
1141 defm V6_vdmpyhisat_acc :
1142      T_HVX_vmpyacc_VWR <"$dst.w += vdmpy($src1.h,$src2.h):sat">,
1143      V6_vdmpyhisat_acc_enc;
1144 defm V6_vdmpyhb_dv_acc :
1145      T_HVX_vmpyacc_WWR <"$dst.w += vdmpy($src1.h,$src2.b)">,
1146      V6_vdmpyhb_dv_acc_enc;
1147 defm V6_vmpybus_acc :
1148      T_HVX_vmpyacc_WVR <"$dst.h += vmpy($src1.ub,$src2.b)">,
1149      V6_vmpybus_acc_enc;
1150 defm V6_vmpabus_acc :
1151      T_HVX_vmpyacc_WWR <"$dst.h += vmpa($src1.ub,$src2.b)">,
1152      V6_vmpabus_acc_enc;
1153 defm V6_vmpahb_acc :
1154      T_HVX_vmpyacc_WWR <"$dst.w += vmpa($src1.h,$src2.b)">,
1155      V6_vmpahb_acc_enc;
1156 defm V6_vmpyhsat_acc :
1157      T_HVX_vmpyacc_WVR <"$dst.w += vmpy($src1.h,$src2.h):sat">,
1158      V6_vmpyhsat_acc_enc;
1159 defm V6_vmpyuh_acc :
1160      T_HVX_vmpyacc_WVR <"$dst.uw += vmpy($src1.uh,$src2.uh)">,
1161      V6_vmpyuh_acc_enc;
1162 defm V6_vmpyiwb_acc :
1163      T_HVX_vmpyacc_VVR <"$dst.w += vmpyi($src1.w,$src2.b)">,
1164      V6_vmpyiwb_acc_enc;
1165 defm V6_vdsaduh_acc :
1166      T_HVX_vmpyacc_WWR <"$dst.uw += vdsad($src1.uh,$src2.uh)">,
1167      V6_vdsaduh_acc_enc;
1168 defm V6_vmpyihb_acc :
1169      T_HVX_vmpyacc_VVR <"$dst.h += vmpyi($src1.h,$src2.b)">,
1170      V6_vmpyihb_acc_enc;
1171 defm V6_vmpyub_acc :
1172      T_HVX_vmpyacc_WVR <"$dst.uh += vmpy($src1.ub,$src2.ub)">,
1173      V6_vmpyub_acc_enc;
1174
1175 let Itinerary = CVI_VX_DV, Type = TypeCVI_VX_DV in {
1176 defm V6_vdmpyhsusat_acc :
1177      T_HVX_vmpyacc_VVR <"$dst.w += vdmpy($src1.h,$src2.uh):sat">,
1178      V6_vdmpyhsusat_acc_enc;
1179 defm V6_vdmpyhsat_acc :
1180      T_HVX_vmpyacc_VVR <"$dst.w += vdmpy($src1.h,$src2.h):sat">,
1181      V6_vdmpyhsat_acc_enc;
1182 defm V6_vmpyiwh_acc : T_HVX_vmpyacc_VVR
1183      <"$dst.w += vmpyi($src1.w,$src2.h)">, V6_vmpyiwh_acc_enc;
1184 }
1185
1186 let Itinerary = CVI_VS, Type = TypeCVI_VS in {
1187 defm V6_vaslw_acc :
1188      T_HVX_vmpyacc_VVR <"$dst.w += vasl($src1.w,$src2)">, V6_vaslw_acc_enc;
1189 defm V6_vasrw_acc :
1190      T_HVX_vmpyacc_VVR <"$dst.w += vasr($src1.w,$src2)">, V6_vasrw_acc_enc;
1191 }
1192
1193 defm V6_vdmpyhvsat_acc :
1194      T_HVX_vmpyacc_VVV <"$dst.w += vdmpy($src1.h,$src2.h):sat">,
1195      V6_vdmpyhvsat_acc_enc;
1196 defm V6_vmpybusv_acc :
1197      T_HVX_vmpyacc_WVV <"$dst.h += vmpy($src1.ub,$src2.b)">,
1198      V6_vmpybusv_acc_enc;
1199 defm V6_vmpybv_acc :
1200      T_HVX_vmpyacc_WVV <"$dst.h += vmpy($src1.b,$src2.b)">, V6_vmpybv_acc_enc;
1201 defm V6_vmpyhus_acc :
1202      T_HVX_vmpyacc_WVV <"$dst.w += vmpy($src1.h,$src2.uh)">, V6_vmpyhus_acc_enc;
1203 defm V6_vmpyhv_acc :
1204      T_HVX_vmpyacc_WVV <"$dst.w += vmpy($src1.h,$src2.h)">, V6_vmpyhv_acc_enc;
1205 defm V6_vmpyiewh_acc :
1206      T_HVX_vmpyacc_VVV <"$dst.w += vmpyie($src1.w,$src2.h)">,
1207      V6_vmpyiewh_acc_enc;
1208 defm V6_vmpyiewuh_acc :
1209      T_HVX_vmpyacc_VVV <"$dst.w += vmpyie($src1.w,$src2.uh)">,
1210      V6_vmpyiewuh_acc_enc;
1211 defm V6_vmpyih_acc :
1212      T_HVX_vmpyacc_VVV <"$dst.h += vmpyi($src1.h,$src2.h)">, V6_vmpyih_acc_enc;
1213 defm V6_vmpyowh_rnd_sacc :
1214      T_HVX_vmpyacc_VVV <"$dst.w += vmpyo($src1.w,$src2.h):<<1:rnd:sat:shift">,
1215      V6_vmpyowh_rnd_sacc_enc;
1216 defm V6_vmpyowh_sacc :
1217      T_HVX_vmpyacc_VVV <"$dst.w += vmpyo($src1.w,$src2.h):<<1:sat:shift">,
1218      V6_vmpyowh_sacc_enc;
1219 defm V6_vmpyubv_acc :
1220      T_HVX_vmpyacc_WVV <"$dst.uh += vmpy($src1.ub,$src2.ub)">,
1221      V6_vmpyubv_acc_enc;
1222 defm V6_vmpyuhv_acc :
1223      T_HVX_vmpyacc_WVV <"$dst.uw += vmpy($src1.uh,$src2.uh)">,
1224      V6_vmpyuhv_acc_enc;
1225 defm V6_vrmpybusv_acc :
1226      T_HVX_vmpyacc_VVV <"$dst.w += vrmpy($src1.ub,$src2.b)">,
1227      V6_vrmpybusv_acc_enc;
1228 defm V6_vrmpybv_acc :
1229      T_HVX_vmpyacc_VVV <"$dst.w += vrmpy($src1.b,$src2.b)">, V6_vrmpybv_acc_enc;
1230 defm V6_vrmpyubv_acc :
1231      T_HVX_vmpyacc_VVV <"$dst.uw += vrmpy($src1.ub,$src2.ub)">,
1232      V6_vrmpyubv_acc_enc;
1233
1234
1235 class T_HVX_vcmp <string asmString, RegisterClass RCout, RegisterClass RCin>
1236   : CVI_VA_Resource1 <(outs RCout:$dst),
1237                       (ins RCout:$_src_, RCin:$src1, RCin:$src2), asmString,
1238                       [], "$dst = $_src_" > {
1239   let Itinerary = CVI_VA;
1240   let Type = TypeCVI_VA;
1241 }
1242
1243 multiclass T_HVX_vcmp <string asmString> {
1244   def NAME : T_HVX_vcmp <asmString, VecPredRegs, VectorRegs>;
1245   let isCodeGenOnly = 1 in
1246   def NAME#_128B : T_HVX_vcmp <asmString, VecPredRegs128B, VectorRegs128B>;
1247 }
1248
1249 defm V6_veqb_and :
1250      T_HVX_vcmp <"$dst &= vcmp.eq($src1.b,$src2.b)">, V6_veqb_and_enc;
1251 defm V6_veqh_and :
1252      T_HVX_vcmp <"$dst &= vcmp.eq($src1.h,$src2.h)">, V6_veqh_and_enc;
1253 defm V6_veqw_and :
1254      T_HVX_vcmp <"$dst &= vcmp.eq($src1.w,$src2.w)">, V6_veqw_and_enc;
1255 defm V6_vgtb_and :
1256      T_HVX_vcmp <"$dst &= vcmp.gt($src1.b,$src2.b)">, V6_vgtb_and_enc;
1257 defm V6_vgth_and :
1258      T_HVX_vcmp <"$dst &= vcmp.gt($src1.h,$src2.h)">, V6_vgth_and_enc;
1259 defm V6_vgtw_and :
1260      T_HVX_vcmp <"$dst &= vcmp.gt($src1.w,$src2.w)">, V6_vgtw_and_enc;
1261 defm V6_vgtub_and :
1262      T_HVX_vcmp <"$dst &= vcmp.gt($src1.ub,$src2.ub)">, V6_vgtub_and_enc;
1263 defm V6_vgtuh_and :
1264      T_HVX_vcmp <"$dst &= vcmp.gt($src1.uh,$src2.uh)">, V6_vgtuh_and_enc;
1265 defm V6_vgtuw_and :
1266      T_HVX_vcmp <"$dst &= vcmp.gt($src1.uw,$src2.uw)">, V6_vgtuw_and_enc;
1267 defm V6_veqb_or :
1268      T_HVX_vcmp <"$dst |= vcmp.eq($src1.b,$src2.b)">, V6_veqb_or_enc;
1269 defm V6_veqh_or :
1270      T_HVX_vcmp <"$dst |= vcmp.eq($src1.h,$src2.h)">, V6_veqh_or_enc;
1271 defm V6_veqw_or :
1272      T_HVX_vcmp <"$dst |= vcmp.eq($src1.w,$src2.w)">, V6_veqw_or_enc;
1273 defm V6_vgtb_or :
1274      T_HVX_vcmp <"$dst |= vcmp.gt($src1.b,$src2.b)">, V6_vgtb_or_enc;
1275 defm V6_vgth_or :
1276      T_HVX_vcmp <"$dst |= vcmp.gt($src1.h,$src2.h)">, V6_vgth_or_enc;
1277 defm V6_vgtw_or :
1278      T_HVX_vcmp <"$dst |= vcmp.gt($src1.w,$src2.w)">, V6_vgtw_or_enc;
1279 defm V6_vgtub_or :
1280      T_HVX_vcmp <"$dst |= vcmp.gt($src1.ub,$src2.ub)">, V6_vgtub_or_enc;
1281 defm V6_vgtuh_or :
1282      T_HVX_vcmp <"$dst |= vcmp.gt($src1.uh,$src2.uh)">, V6_vgtuh_or_enc;
1283 defm V6_vgtuw_or :
1284      T_HVX_vcmp <"$dst |= vcmp.gt($src1.uw,$src2.uw)">, V6_vgtuw_or_enc;
1285 defm V6_veqb_xor :
1286      T_HVX_vcmp <"$dst ^= vcmp.eq($src1.b,$src2.b)">, V6_veqb_xor_enc;
1287 defm V6_veqh_xor :
1288      T_HVX_vcmp <"$dst ^= vcmp.eq($src1.h,$src2.h)">, V6_veqh_xor_enc;
1289 defm V6_veqw_xor :
1290      T_HVX_vcmp <"$dst ^= vcmp.eq($src1.w,$src2.w)">, V6_veqw_xor_enc;
1291 defm V6_vgtb_xor :
1292      T_HVX_vcmp <"$dst ^= vcmp.gt($src1.b,$src2.b)">, V6_vgtb_xor_enc;
1293 defm V6_vgth_xor :
1294      T_HVX_vcmp <"$dst ^= vcmp.gt($src1.h,$src2.h)">, V6_vgth_xor_enc;
1295 defm V6_vgtw_xor :
1296      T_HVX_vcmp <"$dst ^= vcmp.gt($src1.w,$src2.w)">, V6_vgtw_xor_enc;
1297 defm V6_vgtub_xor :
1298      T_HVX_vcmp <"$dst ^= vcmp.gt($src1.ub,$src2.ub)">, V6_vgtub_xor_enc;
1299 defm V6_vgtuh_xor :
1300      T_HVX_vcmp <"$dst ^= vcmp.gt($src1.uh,$src2.uh)">, V6_vgtuh_xor_enc;
1301 defm V6_vgtuw_xor :
1302      T_HVX_vcmp <"$dst ^= vcmp.gt($src1.uw,$src2.uw)">, V6_vgtuw_xor_enc;
1303
1304 defm V6_vminub :
1305      T_HVX_alu_VV <"$dst.ub = vmin($src1.ub,$src2.ub)">, V6_vminub_enc;
1306 defm V6_vminuh :
1307      T_HVX_alu_VV <"$dst.uh = vmin($src1.uh,$src2.uh)">, V6_vminuh_enc;
1308 defm V6_vminh :
1309      T_HVX_alu_VV <"$dst.h = vmin($src1.h,$src2.h)">, V6_vminh_enc;
1310 defm V6_vminw :
1311      T_HVX_alu_VV <"$dst.w = vmin($src1.w,$src2.w)">, V6_vminw_enc;
1312 defm V6_vmaxub :
1313      T_HVX_alu_VV <"$dst.ub = vmax($src1.ub,$src2.ub)">, V6_vmaxub_enc;
1314 defm V6_vmaxuh :
1315      T_HVX_alu_VV <"$dst.uh = vmax($src1.uh,$src2.uh)">, V6_vmaxuh_enc;
1316 defm V6_vmaxh :
1317      T_HVX_alu_VV <"$dst.h = vmax($src1.h,$src2.h)">, V6_vmaxh_enc;
1318 defm V6_vmaxw :
1319      T_HVX_alu_VV <"$dst.w = vmax($src1.w,$src2.w)">, V6_vmaxw_enc;
1320 defm V6_vshuffeb :
1321      T_HVX_alu_VV <"$dst.b = vshuffe($src1.b,$src2.b)">, V6_vshuffeb_enc;
1322 defm V6_vshuffob :
1323      T_HVX_alu_VV <"$dst.b = vshuffo($src1.b,$src2.b)">, V6_vshuffob_enc;
1324 defm V6_vshufeh :
1325      T_HVX_alu_VV <"$dst.h = vshuffe($src1.h,$src2.h)">, V6_vshufeh_enc;
1326 defm V6_vshufoh :
1327      T_HVX_alu_VV <"$dst.h = vshuffo($src1.h,$src2.h)">, V6_vshufoh_enc;
1328
1329 let Itinerary = CVI_VX_DV, Type = TypeCVI_VX_DV in {
1330 defm V6_vmpyowh_rnd :
1331      T_HVX_alu_VV <"$dst.w = vmpyo($src1.w,$src2.h):<<1:rnd:sat">,
1332      V6_vmpyowh_rnd_enc;
1333 defm V6_vmpyiewuh :
1334      T_HVX_alu_VV <"$dst.w = vmpyie($src1.w,$src2.uh)">, V6_vmpyiewuh_enc;
1335 defm V6_vmpyewuh :
1336      T_HVX_alu_VV <"$dst.w = vmpye($src1.w,$src2.uh)">, V6_vmpyewuh_enc;
1337 defm V6_vmpyowh :
1338      T_HVX_alu_VV <"$dst.w = vmpyo($src1.w,$src2.h):<<1:sat">, V6_vmpyowh_enc;
1339 defm V6_vmpyiowh :
1340      T_HVX_alu_VV <"$dst.w = vmpyio($src1.w,$src2.h)">, V6_vmpyiowh_enc;
1341 }
1342 let Itinerary = CVI_VX, Type = TypeCVI_VX in
1343 defm V6_vmpyieoh :
1344      T_HVX_alu_VV <"$dst.w = vmpyieo($src1.h,$src2.h)">, V6_vmpyieoh_enc;
1345
1346 let Itinerary = CVI_VA_DV, Type = TypeCVI_VA_DV in {
1347 defm V6_vshufoeh :
1348      T_HVX_alu_WV <"$dst.h = vshuffoe($src1.h,$src2.h)">, V6_vshufoeh_enc;
1349 defm V6_vshufoeb :
1350      T_HVX_alu_WV <"$dst.b = vshuffoe($src1.b,$src2.b)">, V6_vshufoeb_enc;
1351 }
1352
1353 let isRegSequence = 1, Itinerary = CVI_VA_DV, Type = TypeCVI_VA_DV in
1354 defm V6_vcombine :
1355      T_HVX_alu_WV <"$dst = vcombine($src1,$src2)">, V6_vcombine_enc;
1356
1357 let Itinerary = CVI_VINLANESAT, Type = TypeCVI_VINLANESAT in {
1358 defm V6_vsathub :
1359      T_HVX_alu_VV <"$dst.ub = vsat($src1.h,$src2.h)">, V6_vsathub_enc;
1360 defm V6_vsatwh :
1361      T_HVX_alu_VV <"$dst.h = vsat($src1.w,$src2.w)">, V6_vsatwh_enc;
1362 }
1363
1364 let Itinerary = CVI_VS, Type = TypeCVI_VS in {
1365 defm V6_vroundwh :
1366      T_HVX_alu_VV <"$dst.h = vround($src1.w,$src2.w):sat">, V6_vroundwh_enc;
1367 defm V6_vroundwuh :
1368      T_HVX_alu_VV <"$dst.uh = vround($src1.w,$src2.w):sat">, V6_vroundwuh_enc;
1369 defm V6_vroundhb :
1370      T_HVX_alu_VV <"$dst.b = vround($src1.h,$src2.h):sat">, V6_vroundhb_enc;
1371 defm V6_vroundhub :
1372      T_HVX_alu_VV <"$dst.ub = vround($src1.h,$src2.h):sat">, V6_vroundhub_enc;
1373 defm V6_vasrwv :
1374      T_HVX_alu_VV <"$dst.w = vasr($src1.w,$src2.w)">, V6_vasrwv_enc;
1375 defm V6_vlsrwv :
1376      T_HVX_alu_VV <"$dst.w = vlsr($src1.w,$src2.w)">, V6_vlsrwv_enc;
1377 defm V6_vlsrhv :
1378      T_HVX_alu_VV <"$dst.h = vlsr($src1.h,$src2.h)">, V6_vlsrhv_enc;
1379 defm V6_vasrhv :
1380      T_HVX_alu_VV <"$dst.h = vasr($src1.h,$src2.h)">, V6_vasrhv_enc;
1381 defm V6_vaslwv :
1382      T_HVX_alu_VV <"$dst.w = vasl($src1.w,$src2.w)">, V6_vaslwv_enc;
1383 defm V6_vaslhv :
1384      T_HVX_alu_VV <"$dst.h = vasl($src1.h,$src2.h)">, V6_vaslhv_enc;
1385 }
1386
1387 defm V6_vaddb :
1388      T_HVX_alu_VV <"$dst.b = vadd($src1.b,$src2.b)">, V6_vaddb_enc;
1389 defm V6_vaddh :
1390      T_HVX_alu_VV <"$dst.h = vadd($src1.h,$src2.h)">, V6_vaddh_enc;
1391
1392 let Itinerary = CVI_VP, Type = TypeCVI_VP in {
1393 defm V6_vdelta :
1394      T_HVX_alu_VV <"$dst = vdelta($src1,$src2)">, V6_vdelta_enc;
1395 defm V6_vrdelta :
1396      T_HVX_alu_VV <"$dst = vrdelta($src1,$src2)">, V6_vrdelta_enc;
1397 defm V6_vdealb4w :
1398      T_HVX_alu_VV <"$dst.b = vdeale($src1.b,$src2.b)">, V6_vdealb4w_enc;
1399 defm V6_vpackeb :
1400      T_HVX_alu_VV <"$dst.b = vpacke($src1.h,$src2.h)">, V6_vpackeb_enc;
1401 defm V6_vpackeh :
1402      T_HVX_alu_VV <"$dst.h = vpacke($src1.w,$src2.w)">, V6_vpackeh_enc;
1403 defm V6_vpackhub_sat :
1404      T_HVX_alu_VV <"$dst.ub = vpack($src1.h,$src2.h):sat">, V6_vpackhub_sat_enc;
1405 defm V6_vpackhb_sat :
1406      T_HVX_alu_VV <"$dst.b = vpack($src1.h,$src2.h):sat">, V6_vpackhb_sat_enc;
1407 defm V6_vpackwuh_sat :
1408      T_HVX_alu_VV <"$dst.uh = vpack($src1.w,$src2.w):sat">, V6_vpackwuh_sat_enc;
1409 defm V6_vpackwh_sat :
1410      T_HVX_alu_VV <"$dst.h = vpack($src1.w,$src2.w):sat">, V6_vpackwh_sat_enc;
1411 defm V6_vpackob :
1412      T_HVX_alu_VV <"$dst.b = vpacko($src1.h,$src2.h)">, V6_vpackob_enc;
1413 defm V6_vpackoh :
1414      T_HVX_alu_VV <"$dst.h = vpacko($src1.w,$src2.w)">, V6_vpackoh_enc;
1415 }
1416
1417 let hasNewValue = 1, hasSideEffects = 0 in
1418 class T_HVX_condALU <string asmString, RegisterClass RC1, RegisterClass RC2>
1419   : CVI_VA_Resource1 <(outs RC2:$dst),
1420                       (ins RC1:$src1, RC2:$_src_, RC2:$src2), asmString,
1421                       [], "$dst = $_src_" > {
1422   let Itinerary = CVI_VA;
1423   let Type = TypeCVI_VA;
1424 }
1425
1426 multiclass T_HVX_condALU <string asmString> {
1427   def NAME : T_HVX_condALU <asmString, VecPredRegs, VectorRegs>;
1428   let isCodeGenOnly = 1 in
1429   def NAME#_128B : T_HVX_condALU <asmString, VecPredRegs128B, VectorRegs128B>;
1430 }
1431
1432 defm V6_vaddbq  : T_HVX_condALU <"if ($src1) $dst.b += $src2.b">,
1433                   V6_vaddbq_enc;
1434 defm V6_vaddhq  : T_HVX_condALU <"if ($src1) $dst.h += $src2.h">,
1435                   V6_vaddhq_enc;
1436 defm V6_vaddwq  : T_HVX_condALU <"if ($src1) $dst.w += $src2.w">,
1437                   V6_vaddwq_enc;
1438 defm V6_vsubbq  : T_HVX_condALU <"if ($src1) $dst.b -= $src2.b">,
1439                   V6_vsubbq_enc;
1440 defm V6_vsubhq  : T_HVX_condALU <"if ($src1) $dst.h -= $src2.h">,
1441                   V6_vsubhq_enc;
1442 defm V6_vsubwq  : T_HVX_condALU <"if ($src1) $dst.w -= $src2.w">,
1443                   V6_vsubwq_enc;
1444 defm V6_vaddbnq : T_HVX_condALU <"if (!$src1) $dst.b += $src2.b">,
1445                   V6_vaddbnq_enc;
1446 defm V6_vaddhnq : T_HVX_condALU <"if (!$src1) $dst.h += $src2.h">,
1447                   V6_vaddhnq_enc;
1448 defm V6_vaddwnq : T_HVX_condALU <"if (!$src1) $dst.w += $src2.w">,
1449                   V6_vaddwnq_enc;
1450 defm V6_vsubbnq : T_HVX_condALU <"if (!$src1) $dst.b -= $src2.b">,
1451                   V6_vsubbnq_enc;
1452 defm V6_vsubhnq : T_HVX_condALU <"if (!$src1) $dst.h -= $src2.h">,
1453                   V6_vsubhnq_enc;
1454 defm V6_vsubwnq : T_HVX_condALU <"if (!$src1) $dst.w -= $src2.w">,
1455                   V6_vsubwnq_enc;
1456
1457 let hasNewValue = 1 in
1458 class T_HVX_alu_2op <string asmString, InstrItinClass itin,
1459                  RegisterClass RCout, RegisterClass RCin>
1460   : CVI_VA_Resource1 <(outs RCout:$dst), (ins RCin:$src1),
1461     asmString >{
1462   let Itinerary = itin;
1463   let Type = !cast<IType>("Type"#itin);
1464 }
1465
1466 multiclass T_HVX_alu_2op <string asmString, RegisterClass RCout,
1467            RegisterClass RCin, InstrItinClass itin> {
1468   def NAME : T_HVX_alu_2op <asmString, itin, RCout, RCin>;
1469   let isCodeGenOnly = 1 in
1470   def NAME#_128B : T_HVX_alu_2op <asmString, itin,
1471                               !cast<RegisterClass>(RCout#"128B"),
1472                               !cast<RegisterClass>(RCin#"128B")>;
1473 }
1474
1475 let hasNewValue = 1 in
1476 multiclass T_HVX_alu_2op_VV <string asmString>:
1477   T_HVX_alu_2op <asmString, VectorRegs, VectorRegs, CVI_VA>;
1478
1479 multiclass T_HVX_alu_2op_WV <string asmString>:
1480   T_HVX_alu_2op <asmString, VecDblRegs, VectorRegs, CVI_VA_DV>;
1481
1482
1483 defm V6_vabsh     : T_HVX_alu_2op_VV <"$dst.h = vabs($src1.h)">,
1484                     V6_vabsh_enc;
1485 defm V6_vabsw     : T_HVX_alu_2op_VV <"$dst.w = vabs($src1.w)">,
1486                     V6_vabsw_enc;
1487 defm V6_vabsh_sat : T_HVX_alu_2op_VV <"$dst.h = vabs($src1.h):sat">,
1488                     V6_vabsh_sat_enc;
1489 defm V6_vabsw_sat : T_HVX_alu_2op_VV <"$dst.w = vabs($src1.w):sat">,
1490                     V6_vabsw_sat_enc;
1491 defm V6_vnot      : T_HVX_alu_2op_VV <"$dst = vnot($src1)">,
1492                     V6_vnot_enc;
1493 defm V6_vassign   : T_HVX_alu_2op_VV <"$dst = $src1">,
1494                     V6_vassign_enc;
1495
1496 defm V6_vzb       : T_HVX_alu_2op_WV <"$dst.uh = vzxt($src1.ub)">,
1497                     V6_vzb_enc;
1498 defm V6_vzh       : T_HVX_alu_2op_WV <"$dst.uw = vzxt($src1.uh)">,
1499                     V6_vzh_enc;
1500 defm V6_vsb       : T_HVX_alu_2op_WV <"$dst.h = vsxt($src1.b)">,
1501                     V6_vsb_enc;
1502 defm V6_vsh       : T_HVX_alu_2op_WV <"$dst.w = vsxt($src1.h)">,
1503                     V6_vsh_enc;
1504
1505 let Itinerary = CVI_VP, Type = TypeCVI_VP in {
1506 defm V6_vdealh    : T_HVX_alu_2op_VV <"$dst.h = vdeal($src1.h)">,
1507                     V6_vdealh_enc;
1508 defm V6_vdealb    : T_HVX_alu_2op_VV <"$dst.b = vdeal($src1.b)">,
1509                     V6_vdealb_enc;
1510 defm V6_vshuffh   : T_HVX_alu_2op_VV <"$dst.h = vshuff($src1.h)">,
1511                     V6_vshuffh_enc;
1512 defm V6_vshuffb   : T_HVX_alu_2op_VV <"$dst.b = vshuff($src1.b)">,
1513                     V6_vshuffb_enc;
1514 }
1515
1516 let Itinerary = CVI_VP_VS, Type = TypeCVI_VP_VS in {
1517 defm V6_vunpackub : T_HVX_alu_2op_WV <"$dst.uh = vunpack($src1.ub)">,
1518                     V6_vunpackub_enc;
1519 defm V6_vunpackuh : T_HVX_alu_2op_WV <"$dst.uw = vunpack($src1.uh)">,
1520                     V6_vunpackuh_enc;
1521 defm V6_vunpackb  : T_HVX_alu_2op_WV <"$dst.h = vunpack($src1.b)">,
1522                     V6_vunpackb_enc;
1523 defm V6_vunpackh  : T_HVX_alu_2op_WV <"$dst.w = vunpack($src1.h)">,
1524                     V6_vunpackh_enc;
1525 }
1526
1527 let Itinerary = CVI_VS, Type = TypeCVI_VS in {
1528 defm V6_vcl0w     : T_HVX_alu_2op_VV <"$dst.uw = vcl0($src1.uw)">,
1529                     V6_vcl0w_enc;
1530 defm V6_vcl0h     : T_HVX_alu_2op_VV <"$dst.uh = vcl0($src1.uh)">,
1531                     V6_vcl0h_enc;
1532 defm V6_vnormamtw : T_HVX_alu_2op_VV <"$dst.w = vnormamt($src1.w)">,
1533                     V6_vnormamtw_enc;
1534 defm V6_vnormamth : T_HVX_alu_2op_VV <"$dst.h = vnormamt($src1.h)">,
1535                     V6_vnormamth_enc;
1536 defm V6_vpopcounth : T_HVX_alu_2op_VV <"$dst.h = vpopcount($src1.h)">,
1537                      V6_vpopcounth_enc;
1538 }
1539
1540 let isAccumulator = 1, hasNewValue = 1, Itinerary = CVI_VX_DV_LONG,
1541     Type = TypeCVI_VX_DV in
1542 class T_HVX_vmpyacc2 <string asmString, RegisterClass RC>
1543   : CVI_VA_Resource1 <(outs RC:$dst),
1544                       (ins RC:$_src_, RC:$src1, IntRegs:$src2, u1_0Imm:$src3),
1545     asmString, [], "$dst = $_src_" > ;
1546
1547
1548 multiclass T_HVX_vmpyacc2 <string asmString> {
1549   def NAME : T_HVX_vmpyacc2 <asmString, VecDblRegs>;
1550
1551   let isCodeGenOnly = 1 in
1552   def NAME#_128B : T_HVX_vmpyacc2 <asmString, VecDblRegs128B>;
1553 }
1554
1555 defm V6_vrmpybusi_acc :
1556      T_HVX_vmpyacc2<"$dst.w += vrmpy($src1.ub,$src2.b,#$src3)">,
1557      V6_vrmpybusi_acc_enc;
1558 defm V6_vrsadubi_acc :
1559      T_HVX_vmpyacc2<"$dst.uw += vrsad($src1.ub,$src2.ub,#$src3)">,
1560      V6_vrsadubi_acc_enc;
1561 defm V6_vrmpyubi_acc :
1562      T_HVX_vmpyacc2<"$dst.uw += vrmpy($src1.ub,$src2.ub,#$src3)">,
1563      V6_vrmpyubi_acc_enc;
1564
1565
1566 let Itinerary = CVI_VX_DV_LONG, Type = TypeCVI_VX_DV, hasNewValue = 1 in
1567 class T_HVX_vmpy2 <string asmString, RegisterClass RC>
1568   : CVI_VA_Resource1<(outs RC:$dst), (ins RC:$src1, IntRegs:$src2, u1_0Imm:$src3),
1569     asmString>;
1570
1571
1572 multiclass T_HVX_vmpy2 <string asmString> {
1573   def NAME : T_HVX_vmpy2 <asmString, VecDblRegs>;
1574
1575   let isCodeGenOnly = 1 in
1576   def NAME#_128B : T_HVX_vmpy2 <asmString, VecDblRegs128B>;
1577 }
1578
1579 defm V6_vrmpybusi :
1580      T_HVX_vmpy2 <"$dst.w = vrmpy($src1.ub,$src2.b,#$src3)">, V6_vrmpybusi_enc;
1581 defm V6_vrsadubi :
1582      T_HVX_vmpy2 <"$dst.uw = vrsad($src1.ub,$src2.ub,#$src3)">, V6_vrsadubi_enc;
1583 defm V6_vrmpyubi :
1584      T_HVX_vmpy2 <"$dst.uw = vrmpy($src1.ub,$src2.ub,#$src3)">, V6_vrmpyubi_enc;
1585
1586
1587 let Itinerary = CVI_VP_VS_LONG_EARLY, Type = TypeCVI_VP_VS,
1588     hasSideEffects = 0, hasNewValue2 = 1, opNewValue2 = 1 in
1589 class T_HVX_perm <string asmString, RegisterClass RC>
1590   : CVI_VA_Resource1 <(outs RC:$_dst1_, RC:$_dst2_),
1591                       (ins RC:$src1, RC:$src2, IntRegs:$src3),
1592     asmString, [], "$_dst1_ = $src1, $_dst2_ = $src2" >;
1593
1594 multiclass T_HVX_perm <string asmString> {
1595   def NAME : T_HVX_perm <asmString, VectorRegs>;
1596
1597   let isCodeGenOnly = 1 in
1598   def NAME#_128B : T_HVX_perm <asmString, VectorRegs128B>;
1599 }
1600
1601 let hasNewValue = 1, opNewValue = 0, hasNewValue2 = 1, opNewValue2 = 1 in {
1602   defm V6_vshuff : T_HVX_perm <"vshuff($src1,$src2,$src3)">, V6_vshuff_enc;
1603   defm V6_vdeal : T_HVX_perm <"vdeal($src1,$src2,$src3)">, V6_vdeal_enc;
1604 }
1605
1606 // Conditional vector move.
1607 let isPredicated = 1, hasSideEffects = 0, hasNewValue = 1, opNewValue = 0 in
1608 class T_HVX_cmov <bit isPredNot, RegisterClass RC>
1609   : CVI_VA_Resource1 <(outs RC:$dst), (ins PredRegs:$src1, RC:$src2),
1610     "if ("#!if(isPredNot, "!", "")#"$src1) $dst = $src2"> {
1611   let isPredicatedFalse = isPredNot;
1612 }
1613
1614 multiclass T_HVX_cmov <bit isPredNot = 0> {
1615   def NAME : T_HVX_cmov <isPredNot, VectorRegs>;
1616
1617   let isCodeGenOnly = 1 in
1618   def NAME#_128B : T_HVX_cmov <isPredNot, VectorRegs128B>;
1619 }
1620
1621 defm V6_vcmov : T_HVX_cmov, V6_vcmov_enc;
1622 defm V6_vncmov : T_HVX_cmov<1>, V6_vncmov_enc;
1623
1624 // Conditional vector combine.
1625 let Itinerary = CVI_VA_DV, Type = TypeCVI_VA_DV, isPredicated = 1,
1626     hasSideEffects = 0, hasNewValue = 1, opNewValue = 0 in
1627 class T_HVX_ccombine <bit isPredNot, RegisterClass RCout, RegisterClass RCin>
1628   : CVI_VA_Resource1 < (outs RCout:$dst),
1629     (ins PredRegs:$src1, RCin:$src2, RCin:$src3),
1630     "if ("#!if(isPredNot, "!", "")#"$src1) $dst = vcombine($src2,$src3)"> {
1631   let isPredicatedFalse = isPredNot;
1632 }
1633
1634 multiclass T_HVX_ccombine <bit isPredNot = 0> {
1635   def NAME : T_HVX_ccombine <isPredNot, VecDblRegs, VectorRegs>;
1636
1637   let isCodeGenOnly = 1 in
1638   def NAME#_128B : T_HVX_ccombine <isPredNot, VecDblRegs128B, VectorRegs128B>;
1639 }
1640
1641 defm V6_vccombine : T_HVX_ccombine, V6_vccombine_enc;
1642 defm V6_vnccombine : T_HVX_ccombine<1>, V6_vnccombine_enc;
1643
1644 let hasNewValue = 1 in
1645 class T_HVX_shift <string asmString, RegisterClass RCout, RegisterClass RCin>
1646   : CVI_VX_DV_Resource1<(outs RCout:$dst),
1647     (ins RCin:$src1, RCin:$src2, IntRegsLow8:$src3),
1648     asmString >;
1649
1650 multiclass T_HVX_shift <string asmString, RegisterClass RCout,
1651                         RegisterClass RCin> {
1652   def NAME : T_HVX_shift <asmString, RCout, RCin>;
1653   let isCodeGenOnly = 1 in
1654   def NAME#_128B : T_HVX_shift <asmString, !cast<RegisterClass>(RCout#"128B"),
1655                                            !cast<RegisterClass>(RCin#"128B")>;
1656 }
1657
1658 multiclass T_HVX_shift_VV <string asmString>:
1659   T_HVX_shift <asmString, VectorRegs, VectorRegs>;
1660
1661 multiclass T_HVX_shift_WV <string asmString>:
1662   T_HVX_shift <asmString, VecDblRegs, VectorRegs>;
1663
1664 let Itinerary = CVI_VP_LONG, Type = TypeCVI_VP in {
1665 defm V6_valignb :
1666      T_HVX_shift_VV <"$dst = valign($src1,$src2,$src3)">, V6_valignb_enc;
1667 defm V6_vlalignb :
1668      T_HVX_shift_VV <"$dst = vlalign($src1,$src2,$src3)">, V6_vlalignb_enc;
1669 }
1670
1671 let Itinerary = CVI_VS, Type = TypeCVI_VS in {
1672 defm V6_vasrwh :
1673      T_HVX_shift_VV <"$dst.h = vasr($src1.w,$src2.w,$src3)">, V6_vasrwh_enc;
1674 defm V6_vasrwhsat :
1675      T_HVX_shift_VV <"$dst.h = vasr($src1.w,$src2.w,$src3):sat">,
1676      V6_vasrwhsat_enc;
1677 defm V6_vasrwhrndsat :
1678      T_HVX_shift_VV <"$dst.h = vasr($src1.w,$src2.w,$src3):rnd:sat">,
1679      V6_vasrwhrndsat_enc;
1680 defm V6_vasrwuhsat :
1681      T_HVX_shift_VV <"$dst.uh = vasr($src1.w,$src2.w,$src3):sat">,
1682      V6_vasrwuhsat_enc;
1683 defm V6_vasrhubsat :
1684      T_HVX_shift_VV <"$dst.ub = vasr($src1.h,$src2.h,$src3):sat">,
1685      V6_vasrhubsat_enc;
1686 defm V6_vasrhubrndsat :
1687      T_HVX_shift_VV <"$dst.ub = vasr($src1.h,$src2.h,$src3):rnd:sat">,
1688      V6_vasrhubrndsat_enc;
1689 defm V6_vasrhbrndsat :
1690      T_HVX_shift_VV <"$dst.b = vasr($src1.h,$src2.h,$src3):rnd:sat">,
1691      V6_vasrhbrndsat_enc;
1692 }
1693
1694 // Assembler mapped -- alias?
1695 //defm V6_vtran2x2vdd : T_HVX_shift_VV <"">, V6_vtran2x2vdd_enc;
1696 let Itinerary = CVI_VP_VS_LONG, Type = TypeCVI_VP_VS in {
1697 defm V6_vshuffvdd :
1698      T_HVX_shift_WV <"$dst = vshuff($src1,$src2,$src3)">, V6_vshuffvdd_enc;
1699 defm V6_vdealvdd :
1700      T_HVX_shift_WV <"$dst = vdeal($src1,$src2,$src3)">, V6_vdealvdd_enc;
1701 }
1702
1703 let hasNewValue = 1, Itinerary = CVI_VP_VS_LONG, Type = TypeCVI_VP_VS in
1704 class T_HVX_unpack <string asmString, RegisterClass RCout, RegisterClass RCin>
1705   : CVI_VX_DV_Resource1<(outs RCout:$dst), (ins RCout:$_src_, RCin:$src1),
1706     asmString, [], "$dst = $_src_">;
1707
1708 multiclass T_HVX_unpack <string asmString> {
1709   def NAME : T_HVX_unpack <asmString, VecDblRegs, VectorRegs>;
1710   let isCodeGenOnly = 1 in
1711   def NAME#_128B : T_HVX_unpack <asmString, VecDblRegs128B, VectorRegs128B>;
1712 }
1713
1714 defm V6_vunpackob : T_HVX_unpack <"$dst.h |= vunpacko($src1.b)">, V6_vunpackob_enc;
1715 defm V6_vunpackoh : T_HVX_unpack <"$dst.w |= vunpacko($src1.h)">, V6_vunpackoh_enc;
1716
1717 let Itinerary = CVI_VP_LONG, Type = TypeCVI_VP, hasNewValue = 1,
1718     hasSideEffects = 0 in
1719 class T_HVX_valign <string asmString, RegisterClass RC>
1720   : CVI_VA_Resource1<(outs RC:$dst), (ins RC:$src1, RC:$src2, u3_0Imm:$src3),
1721     asmString>;
1722
1723 multiclass T_HVX_valign <string asmString> {
1724   def NAME : T_HVX_valign <asmString, VectorRegs>;
1725
1726   let isCodeGenOnly = 1 in
1727   def NAME#_128B : T_HVX_valign <asmString, VectorRegs128B>;
1728 }
1729
1730 defm V6_valignbi :
1731      T_HVX_valign <"$dst = valign($src1,$src2,#$src3)">, V6_valignbi_enc;
1732 defm V6_vlalignbi :
1733      T_HVX_valign <"$dst = vlalign($src1,$src2,#$src3)">, V6_vlalignbi_enc;
1734
1735 let Itinerary = CVI_VA_DV, Type = TypeCVI_VA_DV in
1736 class T_HVX_predAlu <string asmString, RegisterClass RC>
1737   : CVI_VA_Resource1<(outs RC:$dst), (ins RC:$src1, RC:$src2),
1738     asmString>;
1739
1740 multiclass T_HVX_predAlu <string asmString> {
1741   def NAME : T_HVX_predAlu <asmString, VecPredRegs>;
1742
1743   let isCodeGenOnly = 1 in
1744   def NAME#_128B : T_HVX_predAlu <asmString, VecPredRegs128B>;
1745 }
1746
1747 defm V6_pred_and  : T_HVX_predAlu <"$dst = and($src1,$src2)">, V6_pred_and_enc;
1748 defm V6_pred_or   : T_HVX_predAlu <"$dst = or($src1,$src2)">, V6_pred_or_enc;
1749 defm V6_pred_xor  : T_HVX_predAlu <"$dst = xor($src1,$src2)">, V6_pred_xor_enc;
1750 defm V6_pred_or_n : T_HVX_predAlu <"$dst = or($src1,!$src2)">, V6_pred_or_n_enc;
1751 defm V6_pred_and_n :
1752      T_HVX_predAlu <"$dst = and($src1,!$src2)">, V6_pred_and_n_enc;
1753
1754 let Itinerary = CVI_VA, Type = TypeCVI_VA in
1755 class T_HVX_prednot <RegisterClass RC>
1756   : CVI_VA_Resource1<(outs RC:$dst), (ins RC:$src1),
1757     "$dst = not($src1)">, V6_pred_not_enc;
1758
1759 def V6_pred_not : T_HVX_prednot <VecPredRegs>;
1760 let isCodeGenOnly =  1 in
1761 def V6_pred_not_128B : T_HVX_prednot <VecPredRegs128B>;
1762
1763 let Itinerary = CVI_VA, Type = TypeCVI_VA in
1764 class T_HVX_vcmp2 <string asmString, RegisterClass RCout, RegisterClass RCin>
1765   : CVI_VA_Resource1 <(outs RCout:$dst), (ins RCin:$src1, RCin:$src2),
1766     asmString >;
1767
1768 multiclass T_HVX_vcmp2 <string asmString> {
1769   def NAME : T_HVX_vcmp2 <asmString, VecPredRegs, VectorRegs>;
1770   let isCodeGenOnly = 1 in
1771   def NAME#_128B : T_HVX_vcmp2 <asmString, VecPredRegs128B, VectorRegs128B>;
1772 }
1773
1774 defm V6_veqb : T_HVX_vcmp2  <"$dst = vcmp.eq($src1.b,$src2.b)">, V6_veqb_enc;
1775 defm V6_veqh : T_HVX_vcmp2  <"$dst = vcmp.eq($src1.h,$src2.h)">, V6_veqh_enc;
1776 defm V6_veqw : T_HVX_vcmp2  <"$dst = vcmp.eq($src1.w,$src2.w)">, V6_veqw_enc;
1777 defm V6_vgtb : T_HVX_vcmp2  <"$dst = vcmp.gt($src1.b,$src2.b)">, V6_vgtb_enc;
1778 defm V6_vgth : T_HVX_vcmp2  <"$dst = vcmp.gt($src1.h,$src2.h)">, V6_vgth_enc;
1779 defm V6_vgtw : T_HVX_vcmp2  <"$dst = vcmp.gt($src1.w,$src2.w)">, V6_vgtw_enc;
1780 defm V6_vgtub : T_HVX_vcmp2 <"$dst = vcmp.gt($src1.ub,$src2.ub)">, V6_vgtub_enc;
1781 defm V6_vgtuh : T_HVX_vcmp2 <"$dst = vcmp.gt($src1.uh,$src2.uh)">, V6_vgtuh_enc;
1782 defm V6_vgtuw : T_HVX_vcmp2 <"$dst = vcmp.gt($src1.uw,$src2.uw)">, V6_vgtuw_enc;
1783
1784 let isAccumulator = 1, hasNewValue = 1, hasSideEffects = 0 in
1785 class T_V6_vandqrt_acc <RegisterClass RCout, RegisterClass RCin>
1786   : CVI_VX_Resource_late<(outs RCout:$dst),
1787     (ins RCout:$_src_, RCin:$src1, IntRegs:$src2),
1788     "$dst |= vand($src1,$src2)", [], "$dst = $_src_">, V6_vandqrt_acc_enc;
1789
1790 def V6_vandqrt_acc : T_V6_vandqrt_acc <VectorRegs, VecPredRegs>;
1791 let isCodeGenOnly = 1 in
1792 def V6_vandqrt_acc_128B : T_V6_vandqrt_acc <VectorRegs128B, VecPredRegs128B>;
1793
1794 let isAccumulator = 1 in
1795 class T_V6_vandvrt_acc <RegisterClass RCout, RegisterClass RCin>
1796   : CVI_VX_Resource_late<(outs RCout:$dst),
1797     (ins RCout:$_src_, RCin:$src1, IntRegs:$src2),
1798     "$dst |= vand($src1,$src2)", [], "$dst = $_src_">, V6_vandvrt_acc_enc;
1799
1800 def V6_vandvrt_acc : T_V6_vandvrt_acc <VecPredRegs, VectorRegs>;
1801 let isCodeGenOnly = 1 in
1802 def V6_vandvrt_acc_128B : T_V6_vandvrt_acc <VecPredRegs128B, VectorRegs128B>;
1803
1804 let hasNewValue =  1, hasSideEffects = 0 in
1805 class T_V6_vandqrt <RegisterClass RCout, RegisterClass RCin>
1806   : CVI_VX_Resource_late<(outs RCout:$dst),
1807     (ins RCin:$src1, IntRegs:$src2),
1808     "$dst = vand($src1,$src2)" >, V6_vandqrt_enc;
1809
1810 def V6_vandqrt : T_V6_vandqrt <VectorRegs, VecPredRegs>;
1811 let isCodeGenOnly = 1 in
1812 def V6_vandqrt_128B : T_V6_vandqrt <VectorRegs128B, VecPredRegs128B>;
1813
1814 let hasNewValue = 1, hasSideEffects = 0 in
1815 class T_V6_lvsplatw <RegisterClass RC>
1816   : CVI_VX_Resource_late<(outs RC:$dst), (ins IntRegs:$src1),
1817     "$dst = vsplat($src1)" >, V6_lvsplatw_enc;
1818
1819 def V6_lvsplatw : T_V6_lvsplatw <VectorRegs>;
1820 let isCodeGenOnly = 1 in
1821 def V6_lvsplatw_128B : T_V6_lvsplatw <VectorRegs128B>;
1822
1823
1824 let hasNewValue = 1 in
1825 class T_V6_vinsertwr <RegisterClass RC>
1826   : CVI_VX_Resource_late<(outs RC:$dst), (ins RC:$_src_, IntRegs:$src1),
1827     "$dst.w = vinsert($src1)", [], "$dst = $_src_">,
1828     V6_vinsertwr_enc;
1829
1830 def V6_vinsertwr : T_V6_vinsertwr <VectorRegs>;
1831 let isCodeGenOnly = 1 in
1832 def V6_vinsertwr_128B : T_V6_vinsertwr <VectorRegs128B>;
1833
1834
1835 let Itinerary = CVI_VP_LONG, Type = TypeCVI_VP in
1836 class T_V6_pred_scalar2 <RegisterClass RC>
1837   : CVI_VA_Resource1<(outs RC:$dst), (ins IntRegs:$src1),
1838     "$dst = vsetq($src1)">, V6_pred_scalar2_enc;
1839
1840 def V6_pred_scalar2 : T_V6_pred_scalar2 <VecPredRegs>;
1841 let isCodeGenOnly = 1 in
1842 def V6_pred_scalar2_128B : T_V6_pred_scalar2 <VecPredRegs128B>;
1843
1844 class T_V6_vandvrt <RegisterClass RCout, RegisterClass RCin>
1845   : CVI_VX_Resource_late<(outs RCout:$dst), (ins RCin:$src1, IntRegs:$src2),
1846     "$dst = vand($src1,$src2)">, V6_vandvrt_enc;
1847
1848 def V6_vandvrt : T_V6_vandvrt <VecPredRegs, VectorRegs>;
1849 let isCodeGenOnly = 1 in
1850 def V6_vandvrt_128B : T_V6_vandvrt <VecPredRegs128B, VectorRegs128B>;
1851
1852 let validSubTargets = HasV60SubT in
1853 class T_HVX_rol <string asmString, RegisterClass RC, Operand ImmOp >
1854   : SInst2 <(outs RC:$dst), (ins  RC:$src1, ImmOp:$src2), asmString>;
1855
1856 class T_HVX_rol_R <string asmString>
1857   : T_HVX_rol <asmString, IntRegs, u5_0Imm>;
1858 class T_HVX_rol_P <string asmString>
1859   : T_HVX_rol <asmString, DoubleRegs, u6_0Imm>;
1860
1861 def S6_rol_i_p : T_HVX_rol_P <"$dst = rol($src1,#$src2)">, S6_rol_i_p_enc;
1862 let hasNewValue = 1, opNewValue = 0 in
1863 def S6_rol_i_r : T_HVX_rol_R <"$dst = rol($src1,#$src2)">, S6_rol_i_r_enc;
1864
1865 let validSubTargets = HasV60SubT in
1866 class T_HVX_rol_acc <string asmString, RegisterClass RC, Operand ImmOp>
1867   : SInst2 <(outs RC:$dst), (ins RC:$_src_, RC:$src1, ImmOp:$src2),
1868     asmString, [], "$dst = $_src_" >;
1869
1870 class T_HVX_rol_acc_P <string asmString>
1871   : T_HVX_rol_acc <asmString, DoubleRegs, u6_0Imm>;
1872
1873 class T_HVX_rol_acc_R <string asmString>
1874   : T_HVX_rol_acc <asmString, IntRegs, u5_0Imm>;
1875
1876 def S6_rol_i_p_nac :
1877     T_HVX_rol_acc_P <"$dst -= rol($src1,#$src2)">, S6_rol_i_p_nac_enc;
1878 def S6_rol_i_p_acc :
1879     T_HVX_rol_acc_P <"$dst += rol($src1,#$src2)">, S6_rol_i_p_acc_enc;
1880 def S6_rol_i_p_and :
1881     T_HVX_rol_acc_P <"$dst &= rol($src1,#$src2)">, S6_rol_i_p_and_enc;
1882 def S6_rol_i_p_or  :
1883     T_HVX_rol_acc_P <"$dst |= rol($src1,#$src2)">, S6_rol_i_p_or_enc;
1884 def S6_rol_i_p_xacc :
1885     T_HVX_rol_acc_P<"$dst ^= rol($src1,#$src2)">, S6_rol_i_p_xacc_enc;
1886
1887 let hasNewValue = 1, opNewValue = 0 in {
1888 def S6_rol_i_r_nac :
1889     T_HVX_rol_acc_R <"$dst -= rol($src1,#$src2)">, S6_rol_i_r_nac_enc;
1890 def S6_rol_i_r_acc :
1891     T_HVX_rol_acc_R <"$dst += rol($src1,#$src2)">, S6_rol_i_r_acc_enc;
1892 def S6_rol_i_r_and :
1893     T_HVX_rol_acc_R <"$dst &= rol($src1,#$src2)">, S6_rol_i_r_and_enc;
1894 def S6_rol_i_r_or :
1895     T_HVX_rol_acc_R <"$dst |= rol($src1,#$src2)">, S6_rol_i_r_or_enc;
1896 def S6_rol_i_r_xacc :
1897     T_HVX_rol_acc_R <"$dst ^= rol($src1,#$src2)">, S6_rol_i_r_xacc_enc;
1898 }
1899
1900 let isSolo = 1, Itinerary = LD_tc_ld_SLOT0, Type = TypeLD in
1901 class T_V6_extractw <RegisterClass RC>
1902   : LD1Inst <(outs IntRegs:$dst), (ins RC:$src1, IntRegs:$src2),
1903     "$dst = vextract($src1,$src2)">, V6_extractw_enc;
1904
1905 def V6_extractw : T_V6_extractw <VectorRegs>;
1906 let isCodeGenOnly = 1 in
1907 def V6_extractw_128B : T_V6_extractw <VectorRegs128B>;
1908
1909 let Itinerary = ST_tc_st_SLOT0, validSubTargets = HasV55SubT  in
1910 class T_sys0op <string asmString>
1911   : ST1Inst <(outs), (ins), asmString>;
1912
1913 let isSolo = 1, validSubTargets = HasV55SubT in {
1914 def Y5_l2gunlock   : T_sys0op <"l2gunlock">, Y5_l2gunlock_enc;
1915 def Y5_l2gclean    : T_sys0op <"l2gclean">, Y5_l2gclean_enc;
1916 def Y5_l2gcleaninv : T_sys0op <"l2gcleaninv">, Y5_l2gcleaninv_enc;
1917 }
1918
1919 class T_sys1op <string asmString, RegisterClass RC>
1920   : ST1Inst <(outs), (ins RC:$src1), asmString>;
1921
1922 class T_sys1op_R <string asmString> : T_sys1op <asmString, IntRegs>;
1923 class T_sys1op_P <string asmString> : T_sys1op <asmString, DoubleRegs>;
1924
1925 let isSoloAX = 1, validSubTargets = HasV55SubT in
1926 def Y5_l2unlocka     : T_sys1op_R <"l2unlocka($src1)">, Y5_l2unlocka_enc;
1927
1928 let isSolo = 1, validSubTargets = HasV60SubT in {
1929 def Y6_l2gcleanpa    : T_sys1op_P <"l2gclean($src1)">, Y6_l2gcleanpa_enc;
1930 def Y6_l2gcleaninvpa : T_sys1op_P <"l2gcleaninv($src1)">, Y6_l2gcleaninvpa_enc;
1931 }
1932
1933 let Itinerary = ST_tc_3stall_SLOT0, isPredicateLate = 1, isSoloAX = 1,
1934     validSubTargets = HasV55SubT in
1935 def Y5_l2locka : ST1Inst <(outs PredRegs:$dst), (ins IntRegs:$src1),
1936   "$dst = l2locka($src1)">, Y5_l2locka_enc;
1937
1938 // not defined on etc side. why?
1939 // defm S2_cabacencbin : _VV <"Rdd=encbin(Rss,$src2,Pu)">, S2_cabacencbin_enc;
1940
1941 let Defs = [USR_OVF], Itinerary = M_tc_3stall_SLOT23, isPredicateLate = 1,
1942     hasSideEffects = 0,
1943 validSubTargets = HasV55SubT in
1944 def A5_ACS : MInst2 <(outs DoubleRegs:$dst1, PredRegs:$dst2),
1945   (ins DoubleRegs:$_src_, DoubleRegs:$src1, DoubleRegs:$src2),
1946   "$dst1,$dst2 = vacsh($src1,$src2)", [],
1947   "$dst1 = $_src_" >, Requires<[HasV55T]>, A5_ACS_enc;
1948
1949 let Itinerary = CVI_VA_DV, Type = TypeCVI_VA_DV, hasNewValue = 1,
1950     hasSideEffects = 0 in
1951 class T_HVX_alu2 <string asmString, RegisterClass RCout, RegisterClass RCin1,
1952                   RegisterClass RCin2>
1953   : CVI_VA_Resource1<(outs RCout:$dst),
1954     (ins RCin1:$src1, RCin2:$src2, RCin2:$src3), asmString>;
1955
1956 multiclass T_HVX_alu2 <string asmString, RegisterClass RC > {
1957   def NAME : T_HVX_alu2 <asmString, RC, VecPredRegs, VectorRegs>;
1958   let isCodeGenOnly = 1 in
1959   def NAME#_128B : T_HVX_alu2 <asmString, !cast<RegisterClass>(RC#"128B"),
1960                                VecPredRegs128B, VectorRegs128B>;
1961 }
1962
1963 multiclass T_HVX_alu2_V <string asmString> :
1964   T_HVX_alu2 <asmString, VectorRegs>;
1965
1966 multiclass T_HVX_alu2_W <string asmString> :
1967   T_HVX_alu2 <asmString, VecDblRegs>;
1968
1969 defm V6_vswap : T_HVX_alu2_W <"$dst = vswap($src1,$src2,$src3)">, V6_vswap_enc;
1970
1971 let Itinerary = CVI_VA, Type = TypeCVI_VA, hasNewValue = 1,
1972     hasSideEffects = 0 in
1973 defm V6_vmux  : T_HVX_alu2_V <"$dst = vmux($src1,$src2,$src3)">, V6_vmux_enc;
1974
1975 class T_HVX_vlutb <string asmString, RegisterClass RCout, RegisterClass RCin>
1976   : CVI_VA_Resource1<(outs RCout:$dst),
1977     (ins RCin:$src1, RCin:$src2, IntRegsLow8:$src3), asmString>;
1978
1979 multiclass T_HVX_vlutb <string asmString, RegisterClass RCout,
1980                         RegisterClass RCin> {
1981   def NAME : T_HVX_vlutb <asmString, RCout, RCin>;
1982   let isCodeGenOnly = 1 in
1983   def NAME#_128B : T_HVX_vlutb <asmString, !cast<RegisterClass>(RCout#"128B"),
1984                                            !cast<RegisterClass>(RCin#"128B")>;
1985 }
1986
1987 multiclass T_HVX_vlutb_V <string asmString> :
1988   T_HVX_vlutb <asmString, VectorRegs, VectorRegs>;
1989
1990 multiclass T_HVX_vlutb_W <string asmString> :
1991   T_HVX_vlutb <asmString, VecDblRegs, VectorRegs>;
1992
1993 let Itinerary = CVI_VP_VS_LONG, Type = TypeCVI_VP_VS, isAccumulator = 1 in
1994 class T_HVX_vlutb_acc <string asmString, RegisterClass RCout,
1995                        RegisterClass RCin>
1996   : CVI_VA_Resource1<(outs RCout:$dst),
1997     (ins RCout:$_src_, RCin:$src1, RCin:$src2, IntRegsLow8:$src3),
1998     asmString, [], "$dst = $_src_">;
1999
2000 multiclass T_HVX_vlutb_acc <string asmString, RegisterClass RCout,
2001                             RegisterClass RCin> {
2002   def NAME : T_HVX_vlutb_acc <asmString, RCout, RCin>;
2003   let isCodeGenOnly = 1 in
2004   def NAME#_128B : T_HVX_vlutb_acc<asmString,
2005                                    !cast<RegisterClass>(RCout#"128B"),
2006                                    !cast<RegisterClass>(RCin#"128B")>;
2007 }
2008
2009 multiclass T_HVX_vlutb_acc_V <string asmString> :
2010   T_HVX_vlutb_acc <asmString, VectorRegs, VectorRegs>;
2011
2012 multiclass T_HVX_vlutb_acc_W <string asmString> :
2013   T_HVX_vlutb_acc <asmString, VecDblRegs, VectorRegs>;
2014
2015
2016 let Itinerary = CVI_VP_LONG, Type = TypeCVI_VP, hasNewValue = 1 in
2017 defm V6_vlutvvb:
2018      T_HVX_vlutb_V <"$dst.b = vlut32($src1.b,$src2.b,$src3)">, V6_vlutvvb_enc;
2019
2020 let Itinerary = CVI_VP_VS_LONG, Type = TypeCVI_VP_VS, hasNewValue = 1 in
2021 defm V6_vlutvwh:
2022      T_HVX_vlutb_W <"$dst.h = vlut16($src1.b,$src2.h,$src3)">, V6_vlutvwh_enc;
2023
2024 let hasNewValue = 1 in {
2025   defm V6_vlutvvb_oracc:
2026        T_HVX_vlutb_acc_V <"$dst.b |= vlut32($src1.b,$src2.b,$src3)">,
2027        V6_vlutvvb_oracc_enc;
2028   defm V6_vlutvwh_oracc:
2029        T_HVX_vlutb_acc_W <"$dst.h |= vlut16($src1.b,$src2.h,$src3)">,
2030        V6_vlutvwh_oracc_enc;
2031 }
2032
2033 // It's a fake instruction and should not be defined?
2034 def S2_cabacencbin
2035   : SInst2<(outs DoubleRegs:$dst),
2036           (ins DoubleRegs:$src1, DoubleRegs:$src2, PredRegs:$src3),
2037     "$dst = encbin($src1,$src2,$src3)">, S2_cabacencbin_enc;
2038
2039 // Vhist instructions
2040 def V6_vhistq
2041   : CVI_HIST_Resource1 <(outs), (ins VecPredRegs:$src1),
2042     "vhist($src1)">, V6_vhistq_enc;
2043
2044 def V6_vhist
2045   : CVI_HIST_Resource1 <(outs), (ins),
2046     "vhist" >, V6_vhist_enc;
2047
2048
2049 let isPseudo = 1, isCodeGenOnly = 1, hasSideEffects = 0 in {
2050   def V6_vd0: CVI_VA_Resource<(outs VectorRegs:$dst), (ins), "$dst = #0", []>;
2051   def V6_vd0_128B: CVI_VA_Resource<(outs VectorRegs128B:$dst), (ins),
2052       "$dst = #0", []>;
2053
2054   def V6_vassignp: CVI_VA_Resource<(outs VecDblRegs:$dst),
2055       (ins VecDblRegs:$src), "", []>;
2056   def V6_vassignp_128B : CVI_VA_Resource<(outs VecDblRegs128B:$dst),
2057       (ins VecDblRegs128B:$src), "", []>;
2058
2059   def V6_lo: CVI_VA_Resource<(outs VectorRegs:$dst), (ins VecDblRegs:$src1),
2060       "", []>;
2061   def V6_lo_128B: CVI_VA_Resource<(outs VectorRegs128B:$dst),
2062       (ins VecDblRegs128B:$src1), "", []>;
2063
2064   def V6_hi: CVI_VA_Resource<(outs VectorRegs:$dst), (ins VecDblRegs:$src1),
2065       "", []>;
2066   def V6_hi_128B: CVI_VA_Resource<(outs VectorRegs128B:$dst),
2067       (ins VecDblRegs128B:$src1), "", []>;
2068 }