radeon/llvm: Remove unused AMDIL TableGen definitons

1 files changed, 0 insertions, 1345 deletions

diff --git a/src/gallium/drivers/radeon/AMDILMultiClass.td b/src/gallium/drivers/radeon/AMDILMultiClass.td
index d6828178ba7..12e92f571e6 100644
--- a/src/gallium/drivers/radeon/AMDILMultiClass.td
+++ b/src/gallium/drivers/radeon/AMDILMultiClass.td
@@ -8,14 +8,6 @@
 //==-----------------------------------------------------------------------===//
 // Multiclass that handles branch instructions
 multiclass BranchConditional<SDNode Op> {
-    def _i8 : ILFormat<IL_OP_IFC, (outs),
-  (ins brtarget:$target, GPRI8:$src0),
-        "; i32 Pseudo branch instruction",
-  [(Op bb:$target, GPRI8:$src0)]>;
-    def _i16 : ILFormat<IL_OP_IFC, (outs),
-  (ins brtarget:$target, GPRI16:$src0),
-        "; i32 Pseudo branch instruction",
-  [(Op bb:$target, GPRI16:$src0)]>;
     def _i32 : ILFormat<IL_OP_IFC, (outs),
   (ins brtarget:$target, GPRI32:$src0),
         "; i32 Pseudo branch instruction",
@@ -24,1417 +16,80 @@ multiclass BranchConditional<SDNode Op> {
   (ins brtarget:$target, GPRF32:$src0),
         "; f32 Pseudo branch instruction",
   [(Op bb:$target, GPRF32:$src0)]>;
-    def _i64 : ILFormat<IL_OP_IFC, (outs),
-  (ins brtarget:$target, GPRI64:$src0),
-        "; f64 Pseudo branch instruction",
-  [(Op bb:$target, (i64 GPRI64:$src0))]>;
-    def _f64 : ILFormat<IL_OP_IFC, (outs),
-  (ins brtarget:$target, GPRF64:$src0),
-        "; f64 Pseudo branch instruction",
-  [(Op bb:$target, (f64 GPRF64:$src0))]>;
-}
-// Multiclass that handles compare instructions
-// When a definition is added here, a corrosponding defition
-// needs to be added at:
-// AMDILISelLowering.cpp@EmitInstrWithCustomInserter
-multiclass Compare<string asm> {
-  def _i8 : ILFormat<IL_OP_CMP, (outs GPRI8:$dst),
-      (ins i32imm:$cc, GPRI8:$src0, GPRI8:$src1),
-      !strconcat("; i8 ", asm),
-      [(set GPRI8:$dst, (IL_cmp imm:$cc, GPRI8:$src0, GPRI8:$src1))]>;
-  def _i16 : ILFormat<IL_OP_CMP, (outs GPRI16:$dst),
-      (ins i32imm:$cc, GPRI16:$src0, GPRI16:$src1),
-      !strconcat("; i16 ", asm),
-      [(set GPRI16:$dst, (IL_cmp imm:$cc, GPRI16:$src0, GPRI16:$src1))]>;
-  def _i32 : ILFormat<IL_OP_CMP, (outs GPRI32:$dst),
-      (ins i32imm:$cc, GPRI32:$src0, GPRI32:$src1),
-      !strconcat("; i32 ", asm),
-      [(set GPRI32:$dst, (IL_cmp imm:$cc, GPRI32:$src0, GPRI32:$src1))]>;
-  def _i64 : ILFormat<IL_OP_CMP, (outs GPRI64:$dst),
-      (ins i32imm:$cc, GPRI64:$src0, GPRI64:$src1),
-      !strconcat("; i64 ", asm),
-      [(set GPRI64:$dst, (IL_cmp imm:$cc, GPRI64:$src0, GPRI64:$src1))]>;
-  def _f32 : ILFormat<IL_OP_CMP, (outs GPRF32:$dst),
-      (ins i32imm:$cc, GPRF32:$src0, GPRF32:$src1),
-      !strconcat("; f32 ", asm),
-      [(set GPRF32:$dst, (IL_cmp imm:$cc, GPRF32:$src0, GPRF32:$src1))]>;
-  def _f64 : ILFormat<IL_OP_CMP, (outs GPRF64:$dst),
-      (ins i32imm:$cc, GPRF64:$src0, GPRF64:$src1),
-      !strconcat("; f64 ", asm),
-      [(set GPRF64:$dst, (IL_cmp imm:$cc, GPRF64:$src0, GPRF64:$src1))]>;
-  def _v2i8 : ILFormat<IL_OP_CMP, (outs GPRV2I8:$dst),
-      (ins i32imm:$cc, GPRV2I8:$src0, GPRV2I8:$src1),
-      !strconcat("; i8 ", asm),
-      [(set GPRV2I8:$dst, (IL_cmp imm:$cc, GPRV2I8:$src0, GPRV2I8:$src1))]>;
-  def _v2i16 : ILFormat<IL_OP_CMP, (outs GPRV2I16:$dst),
-      (ins i32imm:$cc, GPRV2I16:$src0, GPRV2I16:$src1),
-      !strconcat("; i16 ", asm),
-      [(set GPRV2I16:$dst, (IL_cmp imm:$cc, GPRV2I16:$src0, GPRV2I16:$src1))]>;
-  def _v2i32 : ILFormat<IL_OP_CMP, (outs GPRV2I32:$dst),
-      (ins i32imm:$cc, GPRV2I32:$src0, GPRV2I32:$src1),
-      !strconcat("; i32 ", asm),
-      [(set GPRV2I32:$dst, (IL_cmp imm:$cc, GPRV2I32:$src0, GPRV2I32:$src1))]>;
-  def _v2i64 : ILFormat<IL_OP_CMP, (outs GPRV2I64:$dst),
-      (ins i32imm:$cc, GPRV2I64:$src0, GPRV2I64:$src1),
-      !strconcat("; i64 ", asm),
-      [(set GPRV2I64:$dst, (IL_cmp imm:$cc, GPRV2I64:$src0, GPRV2I64:$src1))]>;
-  def _v2f32 : ILFormat<IL_OP_CMP, (outs GPRV2F32:$dst),
-      (ins i32imm:$cc, GPRV2F32:$src0, GPRV2F32:$src1),
-      !strconcat("; f32 ", asm),
-      [(set GPRV2F32:$dst, (IL_cmp imm:$cc, GPRV2F32:$src0, GPRV2F32:$src1))]>;
-  def _v2f64 : ILFormat<IL_OP_CMP, (outs GPRV2F64:$dst),
-      (ins i32imm:$cc, GPRV2F64:$src0, GPRV2F64:$src1),
-      !strconcat("; f64 ", asm),
-      [(set GPRV2F64:$dst, (IL_cmp imm:$cc, GPRV2F64:$src0, GPRV2F64:$src1))]>;
-  def _v4i8 : ILFormat<IL_OP_CMP, (outs GPRV4I8:$dst),
-      (ins i32imm:$cc, GPRV4I8:$src0, GPRV4I8:$src1),
-      !strconcat("; i8 ", asm),
-      [(set GPRV4I8:$dst, (IL_cmp imm:$cc, GPRV4I8:$src0, GPRV4I8:$src1))]>;
-  def _v4i16 : ILFormat<IL_OP_CMP, (outs GPRV4I16:$dst),
-      (ins i32imm:$cc, GPRV4I16:$src0, GPRV4I16:$src1),
-      !strconcat("; i16 ", asm),
-      [(set GPRV4I16:$dst, (IL_cmp imm:$cc, GPRV4I16:$src0, GPRV4I16:$src1))]>;
-  def _v4i32 : ILFormat<IL_OP_CMP, (outs GPRV4I32:$dst),
-      (ins i32imm:$cc, GPRV4I32:$src0, GPRV4I32:$src1),
-      !strconcat("; i32 ", asm),
-      [(set GPRV4I32:$dst, (IL_cmp imm:$cc, GPRV4I32:$src0, GPRV4I32:$src1))]>;
-  def _v4f32 : ILFormat<IL_OP_CMP, (outs GPRV4F32:$dst),
-      (ins i32imm:$cc, GPRV4F32:$src0, GPRV4F32:$src1),
-      !strconcat("; f32 ", asm),
-      [(set GPRV4F32:$dst, (IL_cmp imm:$cc, GPRV4F32:$src0, GPRV4F32:$src1))]>;
-}
-
-// Multiclass that handles constant values
-multiclass ILConstant<string asm> {
-  def _i8 : ILFormat<IL_OP_MOV, (outs GPRI8:$dst),
-      (ins i8imm:$val),
-      asm, [(set GPRI8:$dst, imm:$val)]>;
-
-  //  def _v2i8 : ILFormat<IL_OP_MOV, (outs GPRV2I8:$dst),
-  //      (ins i8imm:$val),
-  //      asm, [(set GPRV2I8:$dst, GPRV2I8:$val)]>;
-
-  //def _v4i8 : ILFormat<IL_OP_MOV, (outs GPRV4I8:$dst),
-  //(ins i8imm:$val),
-  //asm, [(set GPRV4I8:$dst, GPRV4I8:$val)]>;
-
-  def _i16 : ILFormat<IL_OP_MOV, (outs GPRI16:$dst),
-      (ins i16imm:$val),
-      asm, [(set GPRI16:$dst, imm:$val)]>;
-
-  //  def _v2i16 : ILFormat<IL_OP_MOV, (outs GPRV2I16:$dst),
-  //      (ins i16imm:$val),
-  //      asm, [(set GPRV2I16:$dst, GPRV2I16:$val)]>;
-
-  //  def _v4i16 : ILFormat<IL_OP_MOV, (outs GPRV4I16:$dst),
-  //      (ins i16imm:$val),
-  //      asm, [(set GPRV4I16:$dst, GPRV4I16:$val)]>;
-
-  def _i32 : ILFormat<IL_OP_MOV, (outs GPRI32:$dst),
-      (ins i32imm:$val),
-      asm, [(set GPRI32:$dst, imm:$val)]>;
-
-  //  def _v2i32 : ILFormat<IL_OP_MOV, (outs GPRV2I32:$dst),
-  //      (ins i32imm:$val),
-  //      asm, [(set GPRV2I32:$dst, GPRV2I32:$val)]>;
-
-  //  def _v4i32 : ILFormat<IL_OP_MOV, (outs GPRV4I32:$dst),
-  //      (ins GPRV4I32:$val),
-  //      asm, [(set GPRV4I32:$dst, GPRV4I32:$val)]>;
-
-  def _i64 : ILFormat<IL_OP_MOV, (outs GPRI64:$dst),
-      (ins i64imm:$val),
-      asm, [(set GPRI64:$dst, imm:$val)]>;
-
-  //  def _v2i64 : ILFormat<IL_OP_MOV, (outs GPRV2I64:$dst),
-  //      (ins i64imm:$val),
-  //      asm, [(set GPRV2I64:$dst, GPRV2I64:$val)]>;
-
-  def _f32 : ILFormat<IL_OP_MOV, (outs GPRF32:$dst),
-      (ins f32imm:$val),
-      asm, [(set GPRF32:$dst, fpimm:$val)]>;
-
-  //  def _v2f32 : ILFormat<IL_OP_MOV, (outs GPRV2F32:$dst),
-  //      (ins f32imm:$val),
-  //      asm, [(set GPRV2F32:$dst, GPRV2F32:$val)]>;
-
-  //  def _v4f32 : ILFormat<IL_OP_MOV, (outs GPRV4F32:$dst),
-  //      (ins f32imm:$val),
-  //      asm, [(set GPRV4F32:$dst, GPRV4F32:$val)]>;
-
-  def _f64 : ILFormat<IL_OP_MOV, (outs GPRF64:$dst),
-      (ins f64imm:$val),
-      asm, [(set GPRF64:$dst, fpimm:$val)]>;
-
-  //  def _v2f64 : ILFormat<IL_OP_MOV, (outs GPRV2F64:$dst),
-  //      (ins f64imm:$val),
-  //        asm, [(set GPRV2F64:$dst, GPRV2F64:$val)]>;
-
 }
 
 // Multiclass that handles memory store operations
 multiclass GTRUNCSTORE<string asm> {
-  def _i16i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI16:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(global_i8trunc_store GPRI16:$val, ADDR:$ptr)]>;
   def _i32i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI32:$val, MEMI32:$ptr),
       !strconcat(asm, " $val $ptr"),
       [(global_i8trunc_store GPRI32:$val, ADDR:$ptr)]>;
-  def _i64i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(global_i8trunc_store GPRI64:$val, ADDR:$ptr)]>;
   def _i32i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI32:$val, MEMI32:$ptr),
       !strconcat(asm, " $val $ptr"),
       [(global_i16trunc_store GPRI32:$val, ADDR:$ptr)]>;
-  def _i64i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(global_i16trunc_store GPRI64:$val, ADDR:$ptr)]>;
-  def _i64i32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(global_i32trunc_store GPRI64:$val, ADDR:$ptr)]>;
-  def _f64f32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRF64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(global_f32trunc_store GPRF64:$val, ADDR:$ptr)]>;
-  def _v2i32i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I32:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(global_v2i8trunc_store GPRV2I32:$val, ADDR:$ptr)]>;
-  def _v4i32i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV4I32:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(global_v4i8trunc_store GPRV4I32:$val, ADDR:$ptr)]>;
-  def _v2i16i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I16:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(global_v2i8trunc_store GPRV2I16:$val, ADDR:$ptr)]>;
-  def _v4i16i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV4I16:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(global_v4i8trunc_store GPRV4I16:$val, ADDR:$ptr)]>;
-  def _v2i32i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I32:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(global_v2i16trunc_store GPRV2I32:$val, ADDR:$ptr)]>;
-  def _v4i32i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV4I32:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(global_v4i16trunc_store GPRV4I32:$val, ADDR:$ptr)]>;
-  def _v2f64f32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2F64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(global_v2f32trunc_store GPRV2F64:$val, ADDR:$ptr)]>;
-  def _v2i64i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(global_v2i8trunc_store GPRV2I64:$val, ADDR:$ptr)]>;
-  def _v2i64i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(global_v2i16trunc_store GPRV2I64:$val, ADDR:$ptr)]>;
-  def _v2i64i32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(global_v2i32trunc_store GPRV2I64:$val, ADDR:$ptr)]>;
 }
 
 // Multiclass that handles memory store operations
 multiclass LTRUNCSTORE<string asm> {
-  def _i16i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI16:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(local_i8trunc_store GPRI16:$val, ADDR:$ptr)]>;
   def _i32i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI32:$val, MEMI32:$ptr),
       !strconcat(asm, " $val $ptr"),
       [(local_i8trunc_store GPRI32:$val, ADDR:$ptr)]>;
-  def _i64i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(local_i8trunc_store GPRI64:$val, ADDR:$ptr)]>;
   def _i32i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI32:$val, MEMI32:$ptr),
       !strconcat(asm, " $val $ptr"),
       [(local_i16trunc_store GPRI32:$val, ADDR:$ptr)]>;
-  def _i64i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(local_i16trunc_store GPRI64:$val, ADDR:$ptr)]>;
-  def _i64i32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(local_i32trunc_store GPRI64:$val, ADDR:$ptr)]>;
-  def _f64f32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRF64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(local_f32trunc_store GPRF64:$val, ADDR:$ptr)]>;
-  def _v2i32i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I32:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(local_v2i8trunc_store GPRV2I32:$val, ADDR:$ptr)]>;
-  def _v4i32i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV4I32:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(local_v4i8trunc_store GPRV4I32:$val, ADDR:$ptr)]>;
-  def _v2i16i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I16:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(local_v2i8trunc_store GPRV2I16:$val, ADDR:$ptr)]>;
-  def _v4i16i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV4I16:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(local_v4i8trunc_store GPRV4I16:$val, ADDR:$ptr)]>;
-  def _v2i32i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I32:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(local_v2i16trunc_store GPRV2I32:$val, ADDR:$ptr)]>;
-  def _v4i32i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV4I32:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(local_v4i16trunc_store GPRV4I32:$val, ADDR:$ptr)]>;
-  def _v2f64f32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2F64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(local_v2f32trunc_store GPRV2F64:$val, ADDR:$ptr)]>;
-  def _v2i64i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(local_v2i8trunc_store GPRV2I64:$val, ADDR:$ptr)]>;
-  def _v2i64i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(local_v2i16trunc_store GPRV2I64:$val, ADDR:$ptr)]>;
-  def _v2i64i32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(local_v2i32trunc_store GPRV2I64:$val, ADDR:$ptr)]>;
 }
 
 // Multiclass that handles memory store operations
 multiclass PTRUNCSTORE<string asm> {
-  def _i16i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI16:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(private_i8trunc_store GPRI16:$val, ADDR:$ptr)]>;
   def _i32i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI32:$val, MEMI32:$ptr),
       !strconcat(asm, " $val $ptr"),
       [(private_i8trunc_store GPRI32:$val, ADDR:$ptr)]>;
-  def _i64i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(private_i8trunc_store GPRI64:$val, ADDR:$ptr)]>;
   def _i32i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI32:$val, MEMI32:$ptr),
       !strconcat(asm, " $val $ptr"),
       [(private_i16trunc_store GPRI32:$val, ADDR:$ptr)]>;
-  def _i64i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(private_i16trunc_store GPRI64:$val, ADDR:$ptr)]>;
-  def _i64i32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(private_i32trunc_store GPRI64:$val, ADDR:$ptr)]>;
-  def _f64f32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRF64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(private_f32trunc_store GPRF64:$val, ADDR:$ptr)]>;
-  def _v2i32i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I32:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(private_v2i8trunc_store GPRV2I32:$val, ADDR:$ptr)]>;
-  def _v4i32i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV4I32:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(private_v4i8trunc_store GPRV4I32:$val, ADDR:$ptr)]>;
-  def _v2i16i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I16:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(private_v2i8trunc_store GPRV2I16:$val, ADDR:$ptr)]>;
-  def _v4i16i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV4I16:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(private_v4i8trunc_store GPRV4I16:$val, ADDR:$ptr)]>;
-  def _v2i32i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I32:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(private_v2i16trunc_store GPRV2I32:$val, ADDR:$ptr)]>;
-  def _v4i32i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV4I32:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(private_v4i16trunc_store GPRV4I32:$val, ADDR:$ptr)]>;
-  def _v2f64f32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2F64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(private_v2f32trunc_store GPRV2F64:$val, ADDR:$ptr)]>;
-  def _v2i64i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(private_v2i8trunc_store GPRV2I64:$val, ADDR:$ptr)]>;
-  def _v2i64i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(private_v2i16trunc_store GPRV2I64:$val, ADDR:$ptr)]>;
-  def _v2i64i32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(private_v2i32trunc_store GPRV2I64:$val, ADDR:$ptr)]>;
 }
 
 // Multiclass that handles memory store operations
 multiclass RTRUNCSTORE<string asm> {
-  def _i16i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI16:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(region_i8trunc_store GPRI16:$val, ADDR:$ptr)]>;
   def _i32i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI32:$val, MEMI32:$ptr),
       !strconcat(asm, " $val $ptr"),
       [(region_i8trunc_store GPRI32:$val, ADDR:$ptr)]>;
-  def _i64i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(region_i8trunc_store GPRI64:$val, ADDR:$ptr)]>;
   def _i32i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI32:$val, MEMI32:$ptr),
       !strconcat(asm, " $val $ptr"),
       [(region_i16trunc_store GPRI32:$val, ADDR:$ptr)]>;
-  def _i64i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(region_i16trunc_store GPRI64:$val, ADDR:$ptr)]>;
-  def _i64i32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(region_i32trunc_store GPRI64:$val, ADDR:$ptr)]>;
-  def _f64f32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRF64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(region_f32trunc_store GPRF64:$val, ADDR:$ptr)]>;
-  def _v2i32i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I32:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(region_v2i8trunc_store GPRV2I32:$val, ADDR:$ptr)]>;
-  def _v4i32i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV4I32:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(region_v4i8trunc_store GPRV4I32:$val, ADDR:$ptr)]>;
-  def _v2i16i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I16:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(region_v2i8trunc_store GPRV2I16:$val, ADDR:$ptr)]>;
-  def _v4i16i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV4I16:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(region_v4i8trunc_store GPRV4I16:$val, ADDR:$ptr)]>;
-  def _v2i32i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I32:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(region_v2i16trunc_store GPRV2I32:$val, ADDR:$ptr)]>;
-  def _v4i32i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV4I32:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(region_v4i16trunc_store GPRV4I32:$val, ADDR:$ptr)]>;
-  def _v2f64f32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2F64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(region_v2f32trunc_store GPRV2F64:$val, ADDR:$ptr)]>;
-  def _v2i64i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(region_v2i8trunc_store GPRV2I64:$val, ADDR:$ptr)]>;
-  def _v2i64i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(region_v2i16trunc_store GPRV2I64:$val, ADDR:$ptr)]>;
-  def _v2i64i32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(region_v2i32trunc_store GPRV2I64:$val, ADDR:$ptr)]>;
 }
 
 
 // Multiclass that handles memory store operations
 multiclass STORE<string asm, PatFrag OpNode> {
-  def _i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI8:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(OpNode GPRI8:$val, ADDR:$ptr)]>;
-  def _i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI16:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(OpNode GPRI16:$val, ADDR:$ptr)]>;
   def _i32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI32:$val, MEMI32:$ptr),
       !strconcat(asm, " $val $ptr"),
       [(OpNode GPRI32:$val, ADDR:$ptr)]>;
   def _f32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRF32:$val, MEMI32:$ptr),
       !strconcat(asm, " $val $ptr"),
       [(OpNode GPRF32:$val, ADDR:$ptr)]>;
-  def _i64 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(OpNode GPRI64:$val, ADDR:$ptr)]>;
-  def _f64 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRF64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(OpNode GPRF64:$val, ADDR:$ptr)]>;
-  def _v4f32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV4F32:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(OpNode GPRV4F32:$val, ADDR:$ptr)]>;
-  def _v2f32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2F32:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(OpNode GPRV2F32:$val, ADDR:$ptr)]>;
-  def _v4i32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV4I32:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(OpNode GPRV4I32:$val, ADDR:$ptr)]>;
-  def _v2i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I8:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(OpNode GPRV2I8:$val, ADDR:$ptr)]>;
-  def _v2i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I16:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(OpNode GPRV2I16:$val, ADDR:$ptr)]>;
-  def _v4i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV4I8:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(OpNode GPRV4I8:$val, ADDR:$ptr)]>;
-  def _v4i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV4I16:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(OpNode GPRV4I16:$val, ADDR:$ptr)]>;
-  def _v2i32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I32:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(OpNode GPRV2I32:$val, ADDR:$ptr)]>;
-  def _v2f64 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2F64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(OpNode GPRV2F64:$val, ADDR:$ptr)]>;
-  def _v2i64 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I64:$val, MEMI32:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(OpNode GPRV2I64:$val, ADDR:$ptr)]>;
 }
 
 // Multiclass that handles load operations
 multiclass LOAD<string asm, PatFrag OpNode> {
-  def _i8 : OneInOneOut<IL_OP_MOV, (outs GPRI8:$dst), (ins MEMI32:$ptr),
-      !strconcat(asm, " $dst $ptr"),
-      [(set GPRI8:$dst, (OpNode ADDR:$ptr))]>;
-  def _i16 : OneInOneOut<IL_OP_MOV, (outs GPRI16:$dst), (ins MEMI32:$ptr),
-      !strconcat(asm, " $dst $ptr"),
-      [(set GPRI16:$dst, (OpNode ADDR:$ptr))]>;
   def _i32 : OneInOneOut<IL_OP_MOV, (outs GPRI32:$dst), (ins MEMI32:$ptr),
       !strconcat(asm, " $dst $ptr"),
       [(set GPRI32:$dst, (OpNode ADDR:$ptr))]>;
   def _f32 : OneInOneOut<IL_OP_MOV, (outs GPRF32:$dst), (ins MEMI32:$ptr),
       !strconcat(asm, " $dst $ptr"),
       [(set GPRF32:$dst, (OpNode ADDR:$ptr))]>;
-  def _i64 : OneInOneOut<IL_OP_MOV, (outs GPRI64:$dst), (ins MEMI32:$ptr),
-      !strconcat(asm, " $dst $ptr"),
-      [(set GPRI64:$dst, (OpNode ADDR:$ptr))]>;
-  def _f64 : OneInOneOut<IL_OP_MOV, (outs GPRF64:$dst), (ins MEMI32:$ptr),
-      !strconcat(asm, " $dst $ptr"),
-      [(set GPRF64:$dst, (OpNode ADDR:$ptr))]>;
-  def _v4f32 : OneInOneOut<IL_OP_MOV, (outs GPRV4F32:$dst), (ins MEMI32:$ptr),
-      !strconcat(asm, " $dst $ptr"),
-      [(set GPRV4F32:$dst, (OpNode ADDR:$ptr))]>;
-  def _v2f32 : OneInOneOut<IL_OP_MOV, (outs GPRV2F32:$dst), (ins MEMI32:$ptr),
-      !strconcat(asm, " $dst $ptr"),
-      [(set GPRV2F32:$dst, (OpNode ADDR:$ptr))]>;
-  def _v2f64 : OneInOneOut<IL_OP_MOV, (outs GPRV2F64:$dst), (ins MEMI32:$ptr),
-      !strconcat(asm, " $dst $ptr"),
-      [(set GPRV2F64:$dst, (OpNode ADDR:$ptr))]>;
-  def _v4i32 : OneInOneOut<IL_OP_MOV, (outs GPRV4I32:$dst), (ins MEMI32:$ptr),
-      !strconcat(asm, " $dst $ptr"),
-      [(set GPRV4I32:$dst, (OpNode ADDR:$ptr))]>;
-  def _v2i8 : OneInOneOut<IL_OP_MOV, (outs GPRV2I8:$dst), (ins MEMI32:$ptr),
-      !strconcat(asm, " $dst $ptr"),
-      [(set GPRV2I8:$dst, (OpNode ADDR:$ptr))]>;
-  def _v2i16 : OneInOneOut<IL_OP_MOV, (outs GPRV2I16:$dst), (ins MEMI32:$ptr),
-      !strconcat(asm, " $dst $ptr"),
-      [(set GPRV2I16:$dst, (OpNode ADDR:$ptr))]>;
-  def _v4i8 : OneInOneOut<IL_OP_MOV, (outs GPRV4I8:$dst), (ins MEMI32:$ptr),
-      !strconcat(asm, " $dst $ptr"),
-      [(set GPRV4I8:$dst, (OpNode ADDR:$ptr))]>;
-  def _v4i16 : OneInOneOut<IL_OP_MOV, (outs GPRV4I16:$dst), (ins MEMI32:$ptr),
-      !strconcat(asm, " $dst $ptr"),
-      [(set GPRV4I16:$dst, (OpNode ADDR:$ptr))]>;
-  def _v2i32 : OneInOneOut<IL_OP_MOV, (outs GPRV2I32:$dst), (ins MEMI32:$ptr),
-      !strconcat(asm, " $dst $ptr"),
-      [(set GPRV2I32:$dst, (OpNode ADDR:$ptr))]>;
-  def _v2i64 : OneInOneOut<IL_OP_MOV, (outs GPRV2I64:$dst), (ins MEMI32:$ptr),
-      !strconcat(asm, " $dst $ptr"),
-      [(set GPRV2I64:$dst, (OpNode ADDR:$ptr))]>;
-}
-
-// Multiclass that handles memory store operations
-multiclass GTRUNCSTORE64<string asm> {
-  def _i16i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI16:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(global_i8trunc_store GPRI16:$val, ADDR64:$ptr)]>;
-  def _i32i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI32:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(global_i8trunc_store GPRI32:$val, ADDR64:$ptr)]>;
-  def _i64i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(global_i8trunc_store GPRI64:$val, ADDR64:$ptr)]>;
-  def _i32i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI32:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(global_i16trunc_store GPRI32:$val, ADDR64:$ptr)]>;
-  def _i64i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(global_i16trunc_store GPRI64:$val, ADDR64:$ptr)]>;
-  def _i64i32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(global_i32trunc_store GPRI64:$val, ADDR64:$ptr)]>;
-  def _f64f32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRF64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(global_f32trunc_store GPRF64:$val, ADDR64:$ptr)]>;
-  def _v2i32i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I32:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(global_v2i8trunc_store GPRV2I32:$val, ADDR64:$ptr)]>;
-  def _v4i32i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV4I32:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(global_v4i8trunc_store GPRV4I32:$val, ADDR64:$ptr)]>;
-  def _v2i16i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I16:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(global_v2i8trunc_store GPRV2I16:$val, ADDR64:$ptr)]>;
-  def _v4i16i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV4I16:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(global_v4i8trunc_store GPRV4I16:$val, ADDR64:$ptr)]>;
-  def _v2i32i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I32:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(global_v2i16trunc_store GPRV2I32:$val, ADDR64:$ptr)]>;
-  def _v4i32i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV4I32:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(global_v4i16trunc_store GPRV4I32:$val, ADDR64:$ptr)]>;
-  def _v2f64f32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2F64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(global_v2f32trunc_store GPRV2F64:$val, ADDR64:$ptr)]>;
-  def _v2i64i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(global_v2i8trunc_store GPRV2I64:$val, ADDR64:$ptr)]>;
-  def _v2i64i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(global_v2i16trunc_store GPRV2I64:$val, ADDR64:$ptr)]>;
-  def _v2i64i32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(global_v2i32trunc_store GPRV2I64:$val, ADDR64:$ptr)]>;
-}
-
-// Multiclass that handles memory store operations
-multiclass LTRUNCSTORE64<string asm> {
-  def _i16i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI16:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(local_i8trunc_store GPRI16:$val, ADDR64:$ptr)]>;
-  def _i32i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI32:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(local_i8trunc_store GPRI32:$val, ADDR64:$ptr)]>;
-  def _i64i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(local_i8trunc_store GPRI64:$val, ADDR64:$ptr)]>;
-  def _i32i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI32:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(local_i16trunc_store GPRI32:$val, ADDR64:$ptr)]>;
-  def _i64i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(local_i16trunc_store GPRI64:$val, ADDR64:$ptr)]>;
-  def _i64i32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(local_i32trunc_store GPRI64:$val, ADDR64:$ptr)]>;
-  def _f64f32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRF64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(local_f32trunc_store GPRF64:$val, ADDR64:$ptr)]>;
-  def _v2i32i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I32:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(local_v2i8trunc_store GPRV2I32:$val, ADDR64:$ptr)]>;
-  def _v4i32i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV4I32:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(local_v4i8trunc_store GPRV4I32:$val, ADDR64:$ptr)]>;
-  def _v2i16i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I16:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(local_v2i8trunc_store GPRV2I16:$val, ADDR64:$ptr)]>;
-  def _v4i16i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV4I16:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(local_v4i8trunc_store GPRV4I16:$val, ADDR64:$ptr)]>;
-  def _v2i32i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I32:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(local_v2i16trunc_store GPRV2I32:$val, ADDR64:$ptr)]>;
-  def _v4i32i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV4I32:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(local_v4i16trunc_store GPRV4I32:$val, ADDR64:$ptr)]>;
-  def _v2f64f32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2F64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(local_v2f32trunc_store GPRV2F64:$val, ADDR64:$ptr)]>;
-  def _v2i64i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(local_v2i8trunc_store GPRV2I64:$val, ADDR64:$ptr)]>;
-  def _v2i64i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(local_v2i16trunc_store GPRV2I64:$val, ADDR64:$ptr)]>;
-  def _v2i64i32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(local_v2i32trunc_store GPRV2I64:$val, ADDR64:$ptr)]>;
-}
-
-// Multiclass that handles memory store operations
-multiclass PTRUNCSTORE64<string asm> {
-  def _i16i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI16:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(private_i8trunc_store GPRI16:$val, ADDR64:$ptr)]>;
-  def _i32i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI32:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(private_i8trunc_store GPRI32:$val, ADDR64:$ptr)]>;
-  def _i64i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(private_i8trunc_store GPRI64:$val, ADDR64:$ptr)]>;
-  def _i32i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI32:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(private_i16trunc_store GPRI32:$val, ADDR64:$ptr)]>;
-  def _i64i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(private_i16trunc_store GPRI64:$val, ADDR64:$ptr)]>;
-  def _i64i32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(private_i32trunc_store GPRI64:$val, ADDR64:$ptr)]>;
-  def _f64f32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRF64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(private_f32trunc_store GPRF64:$val, ADDR64:$ptr)]>;
-  def _v2i32i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I32:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(private_v2i8trunc_store GPRV2I32:$val, ADDR64:$ptr)]>;
-  def _v4i32i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV4I32:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(private_v4i8trunc_store GPRV4I32:$val, ADDR64:$ptr)]>;
-  def _v2i16i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I16:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(private_v2i8trunc_store GPRV2I16:$val, ADDR64:$ptr)]>;
-  def _v4i16i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV4I16:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(private_v4i8trunc_store GPRV4I16:$val, ADDR64:$ptr)]>;
-  def _v2i32i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I32:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(private_v2i16trunc_store GPRV2I32:$val, ADDR64:$ptr)]>;
-  def _v4i32i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV4I32:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(private_v4i16trunc_store GPRV4I32:$val, ADDR64:$ptr)]>;
-  def _v2f64f32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2F64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(private_v2f32trunc_store GPRV2F64:$val, ADDR64:$ptr)]>;
-  def _v2i64i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(private_v2i8trunc_store GPRV2I64:$val, ADDR64:$ptr)]>;
-  def _v2i64i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(private_v2i16trunc_store GPRV2I64:$val, ADDR64:$ptr)]>;
-  def _v2i64i32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(private_v2i32trunc_store GPRV2I64:$val, ADDR64:$ptr)]>;
-}
-
-// Multiclass that handles memory store operations
-multiclass RTRUNCSTORE64<string asm> {
-  def _i16i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI16:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(region_i8trunc_store GPRI16:$val, ADDR64:$ptr)]>;
-  def _i32i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI32:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(region_i8trunc_store GPRI32:$val, ADDR64:$ptr)]>;
-  def _i64i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(region_i8trunc_store GPRI64:$val, ADDR64:$ptr)]>;
-  def _i32i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI32:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(region_i16trunc_store GPRI32:$val, ADDR64:$ptr)]>;
-  def _i64i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(region_i16trunc_store GPRI64:$val, ADDR64:$ptr)]>;
-  def _i64i32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(region_i32trunc_store GPRI64:$val, ADDR64:$ptr)]>;
-  def _f64f32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRF64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(region_f32trunc_store GPRF64:$val, ADDR64:$ptr)]>;
-  def _v2i32i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I32:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(region_v2i8trunc_store GPRV2I32:$val, ADDR64:$ptr)]>;
-  def _v4i32i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV4I32:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(region_v4i8trunc_store GPRV4I32:$val, ADDR64:$ptr)]>;
-  def _v2i16i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I16:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(region_v2i8trunc_store GPRV2I16:$val, ADDR64:$ptr)]>;
-  def _v4i16i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV4I16:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(region_v4i8trunc_store GPRV4I16:$val, ADDR64:$ptr)]>;
-  def _v2i32i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I32:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(region_v2i16trunc_store GPRV2I32:$val, ADDR64:$ptr)]>;
-  def _v4i32i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV4I32:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(region_v4i16trunc_store GPRV4I32:$val, ADDR64:$ptr)]>;
-  def _v2f64f32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2F64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(region_v2f32trunc_store GPRV2F64:$val, ADDR64:$ptr)]>;
-  def _v2i64i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(region_v2i8trunc_store GPRV2I64:$val, ADDR64:$ptr)]>;
-  def _v2i64i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(region_v2i16trunc_store GPRV2I64:$val, ADDR64:$ptr)]>;
-  def _v2i64i32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(region_v2i32trunc_store GPRV2I64:$val, ADDR64:$ptr)]>;
-}
-
-
-// Multiclass that handles memory store operations
-multiclass STORE64<string asm, PatFrag OpNode> {
-  def _i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI8:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(OpNode GPRI8:$val, ADDR64:$ptr)]>;
-  def _i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI16:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(OpNode GPRI16:$val, ADDR64:$ptr)]>;
-  def _i32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI32:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(OpNode GPRI32:$val, ADDR64:$ptr)]>;
-  def _f32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRF32:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(OpNode GPRF32:$val, ADDR64:$ptr)]>;
-  def _i64 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRI64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(OpNode GPRI64:$val, ADDR64:$ptr)]>;
-  def _f64 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRF64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(OpNode GPRF64:$val, ADDR64:$ptr)]>;
-  def _v4f32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV4F32:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(OpNode GPRV4F32:$val, ADDR64:$ptr)]>;
-  def _v2f32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2F32:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(OpNode GPRV2F32:$val, ADDR64:$ptr)]>;
-  def _v4i32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV4I32:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(OpNode GPRV4I32:$val, ADDR64:$ptr)]>;
-  def _v2i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I8:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(OpNode GPRV2I8:$val, ADDR64:$ptr)]>;
-  def _v2i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I16:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(OpNode GPRV2I16:$val, ADDR64:$ptr)]>;
-  def _v4i8 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV4I8:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(OpNode GPRV4I8:$val, ADDR64:$ptr)]>;
-  def _v4i16 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV4I16:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(OpNode GPRV4I16:$val, ADDR64:$ptr)]>;
-  def _v2i32 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I32:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(OpNode GPRV2I32:$val, ADDR64:$ptr)]>;
-  def _v2f64 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2F64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(OpNode GPRV2F64:$val, ADDR64:$ptr)]>;
-  def _v2i64 : OneInOneOut<IL_OP_MOV, (outs), (ins GPRV2I64:$val, MEMI64:$ptr),
-      !strconcat(asm, " $val $ptr"),
-      [(OpNode GPRV2I64:$val, ADDR64:$ptr)]>;
-}
-
-// Multiclass that handles load operations
-multiclass LOAD64<string asm, PatFrag OpNode> {
-  def _i8 : OneInOneOut<IL_OP_MOV, (outs GPRI8:$dst), (ins MEMI64:$ptr),
-      !strconcat(asm, " $dst $ptr"),
-      [(set GPRI8:$dst, (OpNode ADDR64:$ptr))]>;
-  def _i16 : OneInOneOut<IL_OP_MOV, (outs GPRI16:$dst), (ins MEMI64:$ptr),
-      !strconcat(asm, " $dst $ptr"),
-      [(set GPRI16:$dst, (OpNode ADDR64:$ptr))]>;
-  def _i32 : OneInOneOut<IL_OP_MOV, (outs GPRI32:$dst), (ins MEMI64:$ptr),
-      !strconcat(asm, " $dst $ptr"),
-      [(set GPRI32:$dst, (OpNode ADDR64:$ptr))]>;
-  def _f32 : OneInOneOut<IL_OP_MOV, (outs GPRF32:$dst), (ins MEMI64:$ptr),
-      !strconcat(asm, " $dst $ptr"),
-      [(set GPRF32:$dst, (OpNode ADDR64:$ptr))]>;
-  def _i64 : OneInOneOut<IL_OP_MOV, (outs GPRI64:$dst), (ins MEMI64:$ptr),
-      !strconcat(asm, " $dst $ptr"),
-      [(set GPRI64:$dst, (OpNode ADDR64:$ptr))]>;
-  def _f64 : OneInOneOut<IL_OP_MOV, (outs GPRF64:$dst), (ins MEMI64:$ptr),
-      !strconcat(asm, " $dst $ptr"),
-      [(set GPRF64:$dst, (OpNode ADDR64:$ptr))]>;
-  def _v4f32 : OneInOneOut<IL_OP_MOV, (outs GPRV4F32:$dst), (ins MEMI64:$ptr),
-      !strconcat(asm, " $dst $ptr"),
-      [(set GPRV4F32:$dst, (OpNode ADDR64:$ptr))]>;
-  def _v2f32 : OneInOneOut<IL_OP_MOV, (outs GPRV2F32:$dst), (ins MEMI64:$ptr),
-      !strconcat(asm, " $dst $ptr"),
-      [(set GPRV2F32:$dst, (OpNode ADDR64:$ptr))]>;
-  def _v2f64 : OneInOneOut<IL_OP_MOV, (outs GPRV2F64:$dst), (ins MEMI64:$ptr),
-      !strconcat(asm, " $dst $ptr"),
-      [(set GPRV2F64:$dst, (OpNode ADDR64:$ptr))]>;
-  def _v4i32 : OneInOneOut<IL_OP_MOV, (outs GPRV4I32:$dst), (ins MEMI64:$ptr),
-      !strconcat(asm, " $dst $ptr"),
-      [(set GPRV4I32:$dst, (OpNode ADDR64:$ptr))]>;
-  def _v2i8 : OneInOneOut<IL_OP_MOV, (outs GPRV2I8:$dst), (ins MEMI64:$ptr),
-      !strconcat(asm, " $dst $ptr"),
-      [(set GPRV2I8:$dst, (OpNode ADDR64:$ptr))]>;
-  def _v2i16 : OneInOneOut<IL_OP_MOV, (outs GPRV2I16:$dst), (ins MEMI64:$ptr),
-      !strconcat(asm, " $dst $ptr"),
-      [(set GPRV2I16:$dst, (OpNode ADDR64:$ptr))]>;
-  def _v4i8 : OneInOneOut<IL_OP_MOV, (outs GPRV4I8:$dst), (ins MEMI64:$ptr),
-      !strconcat(asm, " $dst $ptr"),
-      [(set GPRV4I8:$dst, (OpNode ADDR64:$ptr))]>;
-  def _v4i16 : OneInOneOut<IL_OP_MOV, (outs GPRV4I16:$dst), (ins MEMI64:$ptr),
-      !strconcat(asm, " $dst $ptr"),
-      [(set GPRV4I16:$dst, (OpNode ADDR64:$ptr))]>;
-  def _v2i32 : OneInOneOut<IL_OP_MOV, (outs GPRV2I32:$dst), (ins MEMI64:$ptr),
-      !strconcat(asm, " $dst $ptr"),
-      [(set GPRV2I32:$dst, (OpNode ADDR64:$ptr))]>;
-  def _v2i64 : OneInOneOut<IL_OP_MOV, (outs GPRV2I64:$dst), (ins MEMI64:$ptr),
-      !strconcat(asm, " $dst $ptr"),
-      [(set GPRV2I64:$dst, (OpNode ADDR64:$ptr))]>;
 }
 
 // Only scalar types should generate flow control
 multiclass BranchInstr<ILOpCode opc> {
-  def _i8 : UnaryOpNoRet<opc, (outs), (ins GPRI8:$src),
-      !strconcat(opc.Text, " $src"), []>;
-  def _i16 : UnaryOpNoRet<opc, (outs), (ins GPRI16:$src),
-      !strconcat(opc.Text, " $src"), []>;
   def _i32 : UnaryOpNoRet<opc, (outs), (ins GPRI32:$src),
       !strconcat(opc.Text, " $src"), []>;
-  def _i64 : UnaryOpNoRet<opc, (outs), (ins GPRI64:$src),
-      !strconcat(opc.Text, " $src"), []>;
   def _f32 : UnaryOpNoRet<opc, (outs), (ins GPRF32:$src),
       !strconcat(opc.Text, " $src"), []>;
-  def _f64 : UnaryOpNoRet<opc, (outs), (ins GPRF64:$src),
-      !strconcat(opc.Text, " $src"), []>;
 }
 // Only scalar types should generate flow control
 multiclass BranchInstr2<ILOpCode opc> {
-  def _i8 : BinaryOpNoRet<opc, (outs),  (ins  GPRI8:$src0,  GPRI8:$src1),
-      !strconcat(opc.Text, " $src0, $src1"), []>;
-  def _i16 : BinaryOpNoRet<opc, (outs), (ins GPRI16:$src0, GPRI16:$src1),
-      !strconcat(opc.Text, " $src0, $src1"), []>;
   def _i32 : BinaryOpNoRet<opc, (outs), (ins GPRI32:$src0, GPRI32:$src1),
       !strconcat(opc.Text, " $src0, $src1"), []>;
-  def _i64 : BinaryOpNoRet<opc, (outs), (ins GPRI64:$src0, GPRI64:$src1),
-      !strconcat(opc.Text, " $src0, $src1"), []>;
   def _f32 : BinaryOpNoRet<opc, (outs), (ins GPRF32:$src0, GPRF32:$src1),
       !strconcat(opc.Text, " $src0, $src1"), []>;
-  def _f64 : BinaryOpNoRet<opc, (outs), (ins GPRF64:$src0, GPRF64:$src1),
-      !strconcat(opc.Text, " $src0, $src1"), []>;
-}
-
-// Class that handles the various vector extract patterns
-multiclass VectorExtract<SDNode OpNode> {
-  def _v2f64 : ExtractVectorClass<GPRF64, GPRV2F64, OpNode>;
-  def _v4f32: ExtractVectorClass<GPRF32, GPRV4F32, OpNode>;
-  def _v2f32 : ExtractVectorClass<GPRF32, GPRV2F32, OpNode>;
-  def _v2i64 : ExtractVectorClass<GPRI64, GPRV2I64, OpNode>;
-  def _v4i8 : ExtractVectorClass<GPRI8, GPRV4I8, OpNode>;
-  def _v4i16 : ExtractVectorClass<GPRI16, GPRV4I16, OpNode>;
-  def _v4i32 : ExtractVectorClass<GPRI32, GPRV4I32, OpNode>;
-  def _v2i8 : ExtractVectorClass<GPRI8, GPRV2I8, OpNode>;
-  def _v2i16 : ExtractVectorClass<GPRI16, GPRV2I16, OpNode>;
-  def _v2i32 : ExtractVectorClass<GPRI32, GPRV2I32, OpNode>;
-}
-
-multiclass VectorConcat<SDNode OpNode> {
-  def _v2f64 : VectorConcatClass<GPRV2F64, GPRF64, OpNode>;
-  def _v2i64 : VectorConcatClass<GPRV2F64, GPRI64, OpNode>;
-  def _v4f32 : VectorConcatClass<GPRV4F32, GPRV2F32, OpNode>;
-  def _v4i32 : VectorConcatClass<GPRV4I32, GPRV2I32, OpNode>;
-  def _v4i16 : VectorConcatClass<GPRV4I16, GPRV2I16, OpNode>;
-  def _v4i8 : VectorConcatClass<GPRV4I8, GPRV2I8, OpNode>;
-  def _v2f32 : VectorConcatClass<GPRV2F32, GPRF32, OpNode>;
-  def _v2i32 : VectorConcatClass<GPRV2I32, GPRI32, OpNode>;
-  def _v2i16 : VectorConcatClass<GPRV2I16, GPRI16, OpNode>;
-  def _v2i8 : VectorConcatClass<GPRV2I8, GPRI8, OpNode>;
-}
-
-// Class that handles the various vector insert patterns
-multiclass VectorInsert<SDNode OpNode> {
-  def _v2f64 : InsertVectorClass<IL_OP_I_ADD, GPRV2F64,
-      GPRF64, OpNode, "iadd">;
-  def _v4f32: InsertVectorClass<IL_OP_I_ADD, GPRV4F32,
-      GPRF32, OpNode, "iadd">;
-  def _v2f32 : InsertVectorClass<IL_OP_I_ADD, GPRV2F32,
-      GPRF32, OpNode, "iadd">;
-  def _v2i64 : InsertVectorClass<IL_OP_I_ADD, GPRV2I64,
-      GPRI64, OpNode, "iadd">;
-  def _v4i8 : InsertVectorClass<IL_OP_I_ADD, GPRV4I8,
-      GPRI8, OpNode, "iadd">;
-  def _v4i16 : InsertVectorClass<IL_OP_I_ADD, GPRV4I16,
-      GPRI16, OpNode, "iadd">;
-  def _v4i32 : InsertVectorClass<IL_OP_I_ADD, GPRV4I32,
-      GPRI32, OpNode, "iadd">;
-  def _v2i8 : InsertVectorClass<IL_OP_I_ADD, GPRV2I8,
-      GPRI8, OpNode, "iadd">;
-  def _v2i16 : InsertVectorClass<IL_OP_I_ADD, GPRV2I16,
-      GPRI16, OpNode, "iadd">;
-  def _v2i32 : InsertVectorClass<IL_OP_I_ADD, GPRV2I32,
-      GPRI32, OpNode, "iadd">;
-}
-
-// generic class that handles math instruction for OneInOneOut instruction
-// patterns
-multiclass UnaryOpMC<ILOpCode OpCode, SDNode OpNode> {
-  def _i8    : UnaryOp<OpCode, OpNode, GPRI8, GPRI8>;
-  def _i16    : UnaryOp<OpCode, OpNode, GPRI16, GPRI16>;
-  def _i32    : UnaryOp<OpCode, OpNode, GPRI32, GPRI32>;
-  def _f32    : UnaryOp<OpCode, OpNode, GPRF32, GPRF32>;
-  def _f64    : UnaryOp<OpCode, OpNode, GPRF64, GPRF64>;
-  def _i64    : UnaryOp<OpCode, OpNode, GPRI64, GPRI64>;
-  def _v4f32: UnaryOp<OpCode, OpNode, GPRV4F32, GPRV4F32>;
-  def _v4i16  : UnaryOp<OpCode, OpNode, GPRV4I16, GPRV4I16>;
-  def _v4i8  : UnaryOp<OpCode, OpNode, GPRV4I8, GPRV4I8>;
-  def _v4i32  : UnaryOp<OpCode, OpNode, GPRV4I32, GPRV4I32>;
-  def _v2f32  : UnaryOp<OpCode, OpNode, GPRV2F32, GPRV2F32>;
-  def _v2i16  : UnaryOp<OpCode, OpNode, GPRV2I16, GPRV2I16>;
-  def _v2i8  : UnaryOp<OpCode, OpNode, GPRV2I8, GPRV2I8>;
-  def _v2i32  : UnaryOp<OpCode, OpNode, GPRV2I32, GPRV2I32>;
-  def _v2f64  : UnaryOp<OpCode, OpNode, GPRV2F64, GPRV2F64>;
-  def _v2i64  : UnaryOp<OpCode, OpNode, GPRV2I64, GPRV2I64>;
-}
-multiclass UnaryOpMCVec<ILOpCode OpCode, SDNode OpNode> {
-  def _v4f32: UnaryOp<OpCode, OpNode, GPRV4F32, GPRF32>;
-  def _v4i16  : UnaryOp<OpCode, OpNode, GPRV4I16, GPRI16>;
-  def _v4i8  : UnaryOp<OpCode, OpNode, GPRV4I8, GPRI8>;
-  def _v4i32  : UnaryOp<OpCode, OpNode, GPRV4I32, GPRI32>;
-  def _v2f32  : UnaryOp<OpCode, OpNode, GPRV2F32, GPRF32>;
-  def _v2i16  : UnaryOp<OpCode, OpNode, GPRV2I16, GPRI16>;
-  def _v2i8  : UnaryOp<OpCode, OpNode, GPRV2I8, GPRI8>;
-  def _v2i32  : UnaryOp<OpCode, OpNode, GPRV2I32, GPRI32>;
-  def _v2f64  : UnaryOp<OpCode, OpNode, GPRV2F64, GPRF64>;
-  def _v2i64  : UnaryOp<OpCode, OpNode, GPRV2I64, GPRI64>;
-}
-
-multiclass UnaryOpMCf32<
-ILOpCode f32OpCode,
-         SDNode OpNode> {
-           def _f32    : UnaryOp<f32OpCode, OpNode, GPRF32, GPRF32>;
-           def _v4f32: UnaryOp<f32OpCode, OpNode, GPRV4F32, GPRV4F32>;
-           def _v2f32  : UnaryOp<f32OpCode, OpNode, GPRV2F32, GPRV2F32>;
-         }
-
-multiclass UnaryOpMCi32<
-ILOpCode i32OpCode,
-         SDNode OpNode> {
-           def _i8    : UnaryOp<i32OpCode, OpNode, GPRI8, GPRI8>;
-           def _i16    : UnaryOp<i32OpCode, OpNode, GPRI16, GPRI16>;
-           def _i32    : UnaryOp<i32OpCode, OpNode, GPRI32, GPRI32>;
-           def _v4i16  : UnaryOp<i32OpCode, OpNode, GPRV4I16, GPRV4I16>;
-           def _v4i8  : UnaryOp<i32OpCode, OpNode, GPRV4I8, GPRV4I8>;
-           def _v4i32  : UnaryOp<i32OpCode, OpNode, GPRV4I32, GPRV4I32>;
-           def _v2i16  : UnaryOp<i32OpCode, OpNode, GPRV2I16, GPRV2I16>;
-           def _v2i8  : UnaryOp<i32OpCode, OpNode, GPRV2I8, GPRV2I8>;
-           def _v2i32  : UnaryOp<i32OpCode, OpNode, GPRV2I32, GPRV2I32>;
-         }
-
-
-multiclass BinaryOpMC<ILOpCode OpCode, SDNode OpNode> {
-  def _i8    : BinaryOp<OpCode, OpNode, GPRI8, GPRI8, GPRI8>;
-
-  def _i16    : BinaryOp<OpCode, OpNode, GPRI16, GPRI16, GPRI16>;
-  def _i32    : BinaryOp<OpCode, OpNode, GPRI32, GPRI32, GPRI32>;
-  def _f32    : BinaryOp<OpCode, OpNode, GPRF32, GPRF32, GPRF32>;
-  def _f64    : BinaryOp<OpCode, OpNode, GPRF64, GPRF64, GPRF64>;
-  def _i64    : BinaryOp<OpCode, OpNode, GPRI64, GPRI64, GPRI64>;
-  def _v4f32: BinaryOp<OpCode, OpNode, GPRV4F32, GPRV4F32, GPRV4F32>;
-  def _v4i16  : BinaryOp<OpCode, OpNode, GPRV4I16, GPRV4I16, GPRV4I16>;
-  def _v4i8  : BinaryOp<OpCode, OpNode, GPRV4I8, GPRV4I8, GPRV4I8>;
-  def _v4i32  : BinaryOp<OpCode, OpNode, GPRV4I32, GPRV4I32, GPRV4I32>;
-  def _v2f32  : BinaryOp<OpCode, OpNode, GPRV2F32, GPRV2F32, GPRV2F32>;
-  def _v2i16  : BinaryOp<OpCode, OpNode, GPRV2I16, GPRV2I16, GPRV2I16>;
-  def _v2i8  : BinaryOp<OpCode, OpNode, GPRV2I8, GPRV2I8, GPRV2I8>;
-  def _v2i32  : BinaryOp<OpCode, OpNode, GPRV2I32, GPRV2I32, GPRV2I32>;
-  def _v2f64  : BinaryOp<OpCode, OpNode, GPRV2F64, GPRV2F64, GPRV2F64>;
-  def _v2i64  : BinaryOp<OpCode, OpNode, GPRV2I64, GPRV2I64, GPRV2I64>;
-}
-
-multiclass BinaryOpMCInt<ILOpCode OpCode, SDNode OpNode> {
-  def _i8    : BinaryOp<OpCode, OpNode, GPRI8, GPRI8, GPRI8>;
-
-  def _i16    : BinaryOp<OpCode, OpNode, GPRI16, GPRI16, GPRI16>;
-  def _i32    : BinaryOp<OpCode, OpNode, GPRI32, GPRI32, GPRI32>;
-  def _i64    : BinaryOp<OpCode, OpNode, GPRI64, GPRI64, GPRI64>;
-  def _v4i16  : BinaryOp<OpCode, OpNode, GPRV4I16, GPRV4I16, GPRV4I16>;
-  def _v4i8  : BinaryOp<OpCode, OpNode, GPRV4I8, GPRV4I8, GPRV4I8>;
-  def _v4i32  : BinaryOp<OpCode, OpNode, GPRV4I32, GPRV4I32, GPRV4I32>;
-  def _v2i16  : BinaryOp<OpCode, OpNode, GPRV2I16, GPRV2I16, GPRV2I16>;
-  def _v2i8  : BinaryOp<OpCode, OpNode, GPRV2I8, GPRV2I8, GPRV2I8>;
-  def _v2i32  : BinaryOp<OpCode, OpNode, GPRV2I32, GPRV2I32, GPRV2I32>;
-  def _v2i64  : BinaryOp<OpCode, OpNode, GPRV2I64, GPRV2I64, GPRV2I64>;
-}
-
-// generic class that handles math instruction for ThreeInOneOut
-// instruction patterns
-multiclass TernaryOpMC<ILOpCode OpCode, SDNode OpNode> {
-  def _i8    : TernaryOp<OpCode, OpNode, GPRI8, GPRI8, GPRI8, GPRI8>;
-  def _i16    : TernaryOp<OpCode, OpNode, GPRI16, GPRI16, GPRI16, GPRI16>;
-  def _i32    : TernaryOp<OpCode, OpNode, GPRI32, GPRI32, GPRI32, GPRI32>;
-  def _f32    : TernaryOp<OpCode, OpNode, GPRF32, GPRF32, GPRF32, GPRF32>;
-  def _f64    : TernaryOp<OpCode, OpNode, GPRF64, GPRF64, GPRF64, GPRF64>;
-  def _i64    : TernaryOp<OpCode, OpNode, GPRI64, GPRI64, GPRI64, GPRI64>;
-  def _v4f32: TernaryOp<OpCode, OpNode, GPRV4F32, GPRV4F32,
-      GPRV4F32, GPRV4F32>;
-  def _v4i8  : TernaryOp<OpCode, OpNode, GPRV4I8, GPRV4I8,
-      GPRV4I8, GPRV4I8>;
-  def _v4i16  : TernaryOp<OpCode, OpNode, GPRV4I16, GPRV4I16,
-      GPRV4I16, GPRV4I16>;
-  def _v4i32  : TernaryOp<OpCode, OpNode, GPRV4I32, GPRV4I32,
-      GPRV4I32, GPRV4I32>;
-  def _v2f32  : TernaryOp<OpCode, OpNode, GPRV2F32, GPRV2F32,
-      GPRV2F32, GPRV2F32>;
-  def _v2i8  : TernaryOp<OpCode, OpNode, GPRV2I8, GPRV2I8,
-      GPRV2I8, GPRV2I8>;
-  def _v2i16  : TernaryOp<OpCode, OpNode, GPRV2I16, GPRV2I16,
-      GPRV2I16, GPRV2I16>;
-  def _v2i32  : TernaryOp<OpCode, OpNode, GPRV2I32, GPRV2I32,
-      GPRV2I32, GPRV2I32>;
-  def _v2f64  : TernaryOp<OpCode, OpNode, GPRV2F64, GPRV2F64,
-      GPRV2F64, GPRV2F64>;
-  def _v2i64  : TernaryOp<OpCode, OpNode, GPRV2I64, GPRV2I64,
-      GPRV2I64, GPRV2I64>;
-}
-multiclass BinaryOpMCi32<ILOpCode i32OpCode, SDNode OpNode> {
-  def _i8    : BinaryOp<i32OpCode, OpNode, GPRI8, GPRI8, GPRI8>;
-  def _i16   : BinaryOp<i32OpCode, OpNode, GPRI16, GPRI16, GPRI16>;
-  def _i32   : BinaryOp<i32OpCode, OpNode, GPRI32, GPRI32, GPRI32>;
-  def _v4i16 : BinaryOp<i32OpCode, OpNode, GPRV4I16,
-      GPRV4I16, GPRV4I16>;
-  def _v4i8  : BinaryOp<i32OpCode, OpNode, GPRV4I8,
-      GPRV4I8, GPRV4I8>;
-  def _v4i32 : BinaryOp<i32OpCode, OpNode, GPRV4I32,
-      GPRV4I32, GPRV4I32>;
-  def _v2i16 : BinaryOp<i32OpCode, OpNode, GPRV2I16,
-      GPRV2I16, GPRV2I16>;
-  def _v2i8  : BinaryOp<i32OpCode, OpNode, GPRV2I8,
-      GPRV2I8, GPRV2I8>;
-  def _v2i32 : BinaryOp<i32OpCode, OpNode, GPRV2I32,
-      GPRV2I32, GPRV2I32>;
-}
-multiclass BinaryOpMCi64<ILOpCode i64OpCode, SDNode OpNode> {
-  def _i64   : BinaryOp<i64OpCode, OpNode, GPRI64, GPRI64, GPRI64>;
-  def _v2i64 : BinaryOp<i64OpCode, OpNode, GPRV2I64,
-      GPRV2I64, GPRV2I64>;
-}
-multiclass BinaryOpMCi32Const<ILOpCode i32OpCode, SDNode OpNode> {
-  def _i8    : BinaryOp<i32OpCode, OpNode, GPRI8, GPRI8, GPRI32>;
-  def _i16   : BinaryOp<i32OpCode, OpNode, GPRI16, GPRI16, GPRI32>;
-  def _i32   : BinaryOp<i32OpCode, OpNode, GPRI32, GPRI32, GPRI32>;
-  def _v4i16 : BinaryOp<i32OpCode, OpNode, GPRV4I32,
-      GPRV4I32, GPRI32>;
-  def _v4i8  : BinaryOp<i32OpCode, OpNode, GPRV4I32,
-      GPRV4I32, GPRI32>;
-  def _v4i32 : BinaryOp<i32OpCode, OpNode, GPRV4I32,
-      GPRV4I32, GPRI32>;
-  def _v2i16 : BinaryOp<i32OpCode, OpNode, GPRV2I32,
-      GPRV2I32, GPRI32>;
-  def _v2i8  : BinaryOp<i32OpCode, OpNode, GPRV2I32,
-      GPRV2I32, GPRI32>;
-  def _v2i32 : BinaryOp<i32OpCode, OpNode, GPRV2I32,
-      GPRV2I32, GPRI32>;
-}
-multiclass BinaryOpMCf32<ILOpCode f32OpCode, SDNode OpNode> {
-  def _f32    : BinaryOp<f32OpCode, OpNode, GPRF32,
-      GPRF32, GPRF32>;
-  def _v4f32: BinaryOp<f32OpCode, OpNode, GPRV4F32,
-      GPRV4F32, GPRV4F32>;
-  def _v2f32  : BinaryOp<f32OpCode, OpNode, GPRV2F32,
-      GPRV2F32, GPRV2F32>;
-}
-
-multiclass TernaryOpMCf64<ILOpCode f64OpCode, SDNode OpNode> {
-  def _f64    : TernaryOp<f64OpCode, OpNode, GPRF64,
-      GPRF64, GPRF64, GPRF64>;
-}
-
-multiclass TernaryOpMCf32<ILOpCode f32OpCode, SDNode OpNode> {
-  def _f32    : TernaryOp<f32OpCode, OpNode, GPRF32,
-      GPRF32, GPRF32, GPRF32>;
-  def _v4f32: TernaryOp<f32OpCode, OpNode, GPRV4F32,
-      GPRV4F32, GPRV4F32, GPRV4F32>;
-  def _v2f32  : TernaryOp<f32OpCode, OpNode, GPRV2F32,
-      GPRV2F32, GPRV2F32, GPRV2F32>;
-}
-multiclass BinaryOpMCFloat<ILOpCode f32OpCode, ILOpCode f64OpCode,
-           SDNode OpNode> {
-             def _f64    : BinaryOp<f64OpCode, OpNode, GPRF64,
-             GPRF64, GPRF64>;
-             def _v2f64  : BinaryOp<f64OpCode, OpNode, GPRV2F64,
-                 GPRV2F64, GPRV2F64>;
-             def _f32    : BinaryOp<f32OpCode, OpNode, GPRF32,
-                 GPRF32, GPRF32>;
-             def _v2f32  : BinaryOp<f32OpCode, OpNode, GPRV2F32,
-                 GPRV2F32, GPRV2F32>;
-             def _v4f32: BinaryOp<f32OpCode, OpNode, GPRV4F32,
-                 GPRV4F32, GPRV4F32>;
-           }
-
-multiclass TernaryOpMCScalar<ILOpCode opcode, SDNode node>
-{
-    def _i8:  TernaryOp<opcode, node, GPRI8, GPRI8, GPRI8, GPRI8>;
-    def _i16: TernaryOp<opcode, node, GPRI16, GPRI8, GPRI16, GPRI16>;
-    def _i32: TernaryOp<opcode, node, GPRI32, GPRI8, GPRI32, GPRI32>;
-    def _i64: TernaryOp<opcode, node, GPRI64, GPRI8, GPRI64, GPRI64>;
-    def _f32: TernaryOp<opcode, node, GPRF32, GPRI8, GPRF32, GPRF32>;
-    def _f64: TernaryOp<opcode, node, GPRF64, GPRI8, GPRF64, GPRF64>;
-}
-
-
-multiclass BitConversion<ILOpCode opcode, RegisterClass Regs, SDNode OpNode>
-{
-    def _i8    : UnaryOp<opcode, OpNode, Regs,    GPRI8>;
-    def _i16   : UnaryOp<opcode, OpNode, Regs,   GPRI16>;
-    def _i32   : UnaryOp<opcode, OpNode, Regs,   GPRI32>;
-    def _f32   : UnaryOp<opcode, OpNode, Regs,   GPRF32>;
-    def _i64   : UnaryOp<opcode, OpNode, Regs,   GPRI64>;
-    def _f64   : UnaryOp<opcode, OpNode, Regs,   GPRF64>;
-    def _v2i8  : UnaryOp<opcode, OpNode, Regs,  GPRV2I8>;
-    def _v2i16 : UnaryOp<opcode, OpNode, Regs, GPRV2I16>;
-    def _v2i32 : UnaryOp<opcode, OpNode, Regs, GPRV2I32>;
-    def _v2f32 : UnaryOp<opcode, OpNode, Regs, GPRV2F32>;
-    def _v2i64 : UnaryOp<opcode, OpNode, Regs, GPRV2I64>;
-    def _v2f64 : UnaryOp<opcode, OpNode, Regs, GPRV2F64>;
-    def _v4i8  : UnaryOp<opcode, OpNode, Regs,  GPRV4I8>;
-    def _v4i16 : UnaryOp<opcode, OpNode, Regs, GPRV4I16>;
-    def _v4i32 : UnaryOp<opcode, OpNode, Regs, GPRV4I32>;
-    def _v4f32 : UnaryOp<opcode, OpNode, Regs, GPRV4F32>;
-}
-
-
-multiclass UnaryIntrinsicInt<ILOpCode opcode, Intrinsic intr>
-{
-def _i32 : OneInOneOut<opcode, (outs GPRI32:$dst),
-      (ins GPRI32:$src),
-      !strconcat(opcode.Text, " $dst, $src"),
-      [(set GPRI32:$dst, (intr GPRI32:$src))]>;
-def _v2i32 : OneInOneOut<opcode, (outs GPRV2I32:$dst),
-      (ins GPRV2I32:$src),
-      !strconcat(opcode.Text, " $dst, $src"),
-      [(set GPRV2I32:$dst, (intr GPRV2I32:$src))]>;
-def _v4i32 : OneInOneOut<opcode, (outs GPRV4I32:$dst),
-      (ins GPRV4I32:$src),
-      !strconcat(opcode.Text, " $dst, $src"),
-      [(set GPRV4I32:$dst, (intr GPRV4I32:$src))]>;
-}
-
-multiclass IntrConvertF32TOF16<ILOpCode opcode, Intrinsic intr>
-{
-def _i16 : OneInOneOut<opcode, (outs GPRI16:$dst),
-      (ins GPRF32:$src),
-      !strconcat(opcode.Text, " $dst, $src"),
-      [(set GPRI16:$dst, (intr GPRF32:$src))]>;
-def _v2i16 : OneInOneOut<opcode, (outs GPRV2I16:$dst),
-      (ins GPRV2F32:$src),
-      !strconcat(opcode.Text, " $dst, $src"),
-      [(set GPRV2I16:$dst, (intr GPRV2F32:$src))]>;
-def _v4i16 : OneInOneOut<opcode, (outs GPRV4I16:$dst),
-      (ins GPRV4F32:$src),
-      !strconcat(opcode.Text, " $dst, $src"),
-      [(set GPRV4I16:$dst, (intr GPRV4F32:$src))]>;
-}
-
-
-multiclass IntrConvertF32TOI32<ILOpCode opcode, Intrinsic intr>
-{
-def _i32 : OneInOneOut<opcode, (outs GPRI32:$dst),
-      (ins GPRF32:$src),
-      !strconcat(opcode.Text, " $dst, $src"),
-      [(set GPRI32:$dst, (intr GPRF32:$src))]>;
-def _v2i32 : OneInOneOut<opcode, (outs GPRV2I32:$dst),
-      (ins GPRV2F32:$src),
-      !strconcat(opcode.Text, " $dst, $src"),
-      [(set GPRV2I32:$dst, (intr GPRV2F32:$src))]>;
-def _v4i32 : OneInOneOut<opcode, (outs GPRV4I32:$dst),
-      (ins GPRV4F32:$src),
-      !strconcat(opcode.Text, " $dst, $src"),
-      [(set GPRV4I32:$dst, (intr GPRV4F32:$src))]>;
-}
-
-multiclass IntrConvertF64TOI32<ILOpCode opcode, Intrinsic intr>
-{
-def _i32 : OneInOneOut<opcode, (outs GPRI32:$dst),
-      (ins GPRF64:$src),
-      !strconcat(opcode.Text, " $dst, $src"),
-      [(set GPRI32:$dst, (intr GPRF64:$src))]>;
-def _v2i32 : OneInOneOut<opcode, (outs GPRV2I32:$dst),
-      (ins GPRV2F64:$src),
-      !strconcat(opcode.Text, " $dst, $src"),
-      [(set GPRV2I32:$dst, (intr GPRV2F64:$src))]>;
-}
-
-multiclass IntrConvertF16TOF32<ILOpCode opcode, Intrinsic intr>
-{
-def _f32 : OneInOneOut<opcode, (outs GPRF32:$dst),
-      (ins GPRI16:$src),
-      !strconcat(opcode.Text, " $dst, $src"),
-      [(set GPRF32:$dst, (intr GPRI16:$src))]>;
-def _v2f32 : OneInOneOut<opcode, (outs GPRV2F32:$dst),
-      (ins GPRV2I16:$src),
-      !strconcat(opcode.Text, " $dst, $src"),
-      [(set GPRV2F32:$dst, (intr GPRV2I16:$src))]>;
-def _v4f32 : OneInOneOut<opcode, (outs GPRV4F32:$dst),
-      (ins GPRV4I16:$src),
-      !strconcat(opcode.Text, " $dst, $src"),
-      [(set GPRV4F32:$dst, (intr GPRV4I16:$src))]>;
-}
-
-
-multiclass IntrConvertI32TOF32<ILOpCode opcode, Intrinsic intr>
-{
-def _f32 : OneInOneOut<opcode, (outs GPRF32:$dst),
-      (ins GPRI32:$src),
-      !strconcat(opcode.Text, " $dst, $src"),
-      [(set GPRF32:$dst, (intr GPRI32:$src))]>;
-def _v2f32 : OneInOneOut<opcode, (outs GPRV2F32:$dst),
-      (ins GPRV2I32:$src),
-      !strconcat(opcode.Text, " $dst, $src"),
-      [(set GPRV2F32:$dst, (intr GPRV2I32:$src))]>;
-def _v4f32 : OneInOneOut<opcode, (outs GPRV4F32:$dst),
-      (ins GPRV4I32:$src),
-      !strconcat(opcode.Text, " $dst, $src"),
-      [(set GPRV4F32:$dst, (intr GPRV4I32:$src))]>;
-}
-
-multiclass BinaryIntrinsicLong<ILOpCode opcode, Intrinsic intr>
-{
-def _i64 : TwoInOneOut<opcode, (outs GPRI64:$dst),
-      (ins GPRI64:$src, GPRI64:$src2),
-      !strconcat(opcode.Text, " $dst, $src, $src2"),
-      [(set GPRI64:$dst,
-      (intr GPRI64:$src, GPRI64:$src2))]>;
-}
-
-
-multiclass BinaryIntrinsicInt<ILOpCode opcode, Intrinsic intr>
-{
-def _i32 : TwoInOneOut<opcode, (outs GPRI32:$dst),
-      (ins GPRI32:$src, GPRI32:$src2),
-      !strconcat(opcode.Text, " $dst, $src, $src2"),
-      [(set GPRI32:$dst,
-      (intr GPRI32:$src, GPRI32:$src2))]>;
-def _v2i32 : TwoInOneOut<opcode, (outs GPRV2I32:$dst),
-      (ins GPRV2I32:$src, GPRV2I32:$src2),
-      !strconcat(opcode.Text, " $dst, $src, $src2"),
-      [(set GPRV2I32:$dst,
-      (intr GPRV2I32:$src, GPRV2I32:$src2))]>;
-def _v4i32 : TwoInOneOut<opcode, (outs GPRV4I32:$dst),
-      (ins GPRV4I32:$src, GPRV4I32:$src2),
-      !strconcat(opcode.Text, " $dst, $src, $src2"),
-      [(set GPRV4I32:$dst,
-      (intr GPRV4I32:$src, GPRV4I32:$src2))]>;
-}
-
-multiclass TernaryIntrinsicInt<ILOpCode opcode, Intrinsic intr>
-{
-def _i32 : ThreeInOneOut<opcode, (outs GPRI32:$dst),
-      (ins GPRI32:$src, GPRI32:$src2, GPRI32:$src3),
-      !strconcat(opcode.Text, " $dst, $src, $src2, $src3"),
-      [(set GPRI32:$dst,
-      (intr GPRI32:$src, GPRI32:$src2, GPRI32:$src3))]>;
-def _v2i32 : ThreeInOneOut<opcode, (outs GPRV2I32:$dst),
-      (ins GPRV2I32:$src, GPRV2I32:$src2, GPRV2I32:$src3),
-      !strconcat(opcode.Text, " $dst, $src, $src2, $src3"),
-      [(set GPRV2I32:$dst,
-      (intr GPRV2I32:$src, GPRV2I32:$src2, GPRV2I32:$src3))]>;
-def _v4i32 : ThreeInOneOut<opcode, (outs GPRV4I32:$dst),
-      (ins GPRV4I32:$src, GPRV4I32:$src2, GPRV4I32:$src3),
-      !strconcat(opcode.Text, " $dst, $src, $src2, $src3"),
-      [(set GPRV4I32:$dst,
-      (intr GPRV4I32:$src, GPRV4I32:$src2, GPRV4I32:$src3))]>;
-}
-
-multiclass TernaryIntrinsicFloat<ILOpCode opcode, Intrinsic intr>
-{
-def _f32 : ThreeInOneOut<opcode, (outs GPRF32:$dst),
-      (ins GPRF32:$src, GPRF32:$src2, GPRF32:$src3),
-      !strconcat(opcode.Text, " $dst, $src, $src2, $src3"),
-      [(set GPRF32:$dst,
-      (intr GPRF32:$src, GPRF32:$src2, GPRF32:$src3))]>;
-def _v2f32 : ThreeInOneOut<opcode, (outs GPRV2F32:$dst),
-      (ins GPRV2F32:$src, GPRV2F32:$src2, GPRV2F32:$src3),
-      !strconcat(opcode.Text, " $dst, $src, $src2, $src3"),
-      [(set GPRV2F32:$dst,
-      (intr GPRV2F32:$src, GPRV2F32:$src2, GPRV2F32:$src3))]>;
-def _v4f32 : ThreeInOneOut<opcode, (outs GPRV4F32:$dst),
-      (ins GPRV4F32:$src, GPRV4F32:$src2, GPRV4F32:$src3),
-      !strconcat(opcode.Text, " $dst, $src, $src2, $src3"),
-      [(set GPRV4F32:$dst,
-      (intr GPRV4F32:$src, GPRV4F32:$src2, GPRV4F32:$src3))]>;
-}
-
-multiclass BinaryIntrinsicDoubleScalar<ILOpCode opcode, Intrinsic intr>
-{
-def _f64 : ThreeInOneOut<opcode, (outs GPRF64:$dst),
-      (ins GPRF64:$src, GPRF64:$src2),
-      !strconcat(opcode.Text, " $dst, $src, $src2"),
-      [(set GPRF64:$dst,
-      (intr GPRF64:$src, GPRF64:$src2))]>;
-}
-
-multiclass TernaryIntrinsicDoubleScalar<ILOpCode opcode, Intrinsic intr>
-{
-def _f64 : ThreeInOneOut<opcode, (outs GPRF64:$dst),
-      (ins GPRF64:$src, GPRF64:$src2, GPRF64:$src3),
-      !strconcat(opcode.Text, " $dst, $src, $src2, $src3"),
-      [(set GPRF64:$dst,
-      (intr GPRF64:$src, GPRF64:$src2, GPRF64:$src3))]>;
-}
-
-
-multiclass TernaryIntrinsicLongScalar<ILOpCode opcode, Intrinsic intr>
-{
-def _i64 : ThreeInOneOut<opcode, (outs GPRI64:$dst),
-      (ins GPRI64:$src, GPRI64:$src2, GPRI64:$src3),
-      !strconcat(opcode.Text, " $dst, $src, $src2, $src3"),
-      [(set GPRI64:$dst,
-      (intr GPRI64:$src, GPRI64:$src2, GPRI64:$src3))]>;
-}
-
-multiclass QuaternaryIntrinsicInt<ILOpCode opcode, Intrinsic intr>
-{
-def _i32 : FourInOneOut<opcode, (outs GPRI32:$dst),
-      (ins GPRI32:$src, GPRI32:$src2, GPRI32:$src3, GPRI32:$src4),
-      !strconcat(opcode.Text, " $dst, $src, $src2, $src3, $src4"),
-      [(set GPRI32:$dst,
-      (intr GPRI32:$src, GPRI32:$src2, GPRI32:$src3, GPRI32:$src4))]>;
-def _v2i32 : FourInOneOut<opcode, (outs GPRV2I32:$dst),
-      (ins GPRV2I32:$src, GPRV2I32:$src2, GPRV2I32:$src3, GPRV2I32:$src4),
-      !strconcat(opcode.Text, " $dst, $src, $src2, $src3, $src4"),
-      [(set GPRV2I32:$dst,
-      (intr GPRV2I32:$src, GPRV2I32:$src2, GPRV2I32:$src3, GPRV2I32:$src4))]>;
-def _v4i32 : FourInOneOut<opcode, (outs GPRV4I32:$dst),
-      (ins GPRV4I32:$src, GPRV4I32:$src2, GPRV4I32:$src3, GPRV4I32:$src4),
-      !strconcat(opcode.Text, " $dst, $src, $src2, $src3, $src4"),
-      [(set GPRV4I32:$dst,
-      (intr GPRV4I32:$src, GPRV4I32:$src2, GPRV4I32:$src3, GPRV4I32:$src4))]>;
-}
-
-multiclass UnaryIntrinsicFloatScalar<ILOpCode opcode, Intrinsic intr>
-{
-def _f32 : OneInOneOut<opcode, (outs GPRF32:$dst),
-      (ins GPRF32:$src),
-      !strconcat(opcode.Text, " $dst, $src"),
-      [(set GPRF32:$dst, (intr GPRF32:$src))]>;
-}
-
-multiclass UnaryIntrinsicFloat<ILOpCode opcode, Intrinsic intr>
-{
-def _f32 : OneInOneOut<opcode, (outs GPRF32:$dst),
-      (ins GPRF32:$src),
-      !strconcat(opcode.Text, " $dst, $src"),
-      [(set GPRF32:$dst, (intr GPRF32:$src))]>;
-def _v2f32 : OneInOneOut<opcode, (outs GPRV2F32:$dst),
-      (ins GPRV2F32:$src),
-      !strconcat(opcode.Text, " $dst, $src"),
-      [(set GPRV2F32:$dst, (intr GPRV2F32:$src))]>;
-def _v4f32 : OneInOneOut<opcode, (outs GPRV4F32:$dst),
-      (ins GPRV4F32:$src),
-      !strconcat(opcode.Text, " $dst, $src"),
-      [(set GPRV4F32:$dst, (intr GPRV4F32:$src))]>;
-}
-
-multiclass BinaryIntrinsicFloatScalar<ILOpCode opcode, Intrinsic intr>
-{
-def _f32 : TwoInOneOut<opcode, (outs GPRF32:$dst),
-      (ins GPRF32:$src, GPRF32:$src2),
-      !strconcat(opcode.Text, " $dst, $src, $src2"),
-      [(set GPRF32:$dst,
-      (intr GPRF32:$src, GPRF32:$src2))]>;
-}
-multiclass BinaryIntrinsicFloat<ILOpCode opcode, Intrinsic intr>
-{
-def _f32 : TwoInOneOut<opcode, (outs GPRF32:$dst),
-      (ins GPRF32:$src, GPRF32:$src2),
-      !strconcat(opcode.Text, " $dst, $src, $src2"),
-      [(set GPRF32:$dst,
-      (intr GPRF32:$src, GPRF32:$src2))]>;
-def _v2f32 : TwoInOneOut<opcode, (outs GPRV2F32:$dst),
-      (ins GPRV2F32:$src, GPRV2F32:$src2),
-      !strconcat(opcode.Text, " $dst, $src, $src2"),
-      [(set GPRV2F32:$dst,
-      (intr GPRV2F32:$src, GPRV2F32:$src2))]>;
-def _v4f32 : TwoInOneOut<opcode, (outs GPRV4F32:$dst),
-      (ins GPRV4F32:$src, GPRV4F32:$src2),
-      !strconcat(opcode.Text, " $dst, $src, $src2"),
-      [(set GPRV4F32:$dst,
-      (intr GPRV4F32:$src, GPRV4F32:$src2))]>;
-}
-
-multiclass UnaryIntrinsicDoubleScalar<ILOpCode opcode, Intrinsic intr>
-{
-def _f64 : OneInOneOut<opcode, (outs GPRF64:$dst),
-      (ins GPRF64:$src),
-      !strconcat(opcode.Text, " $dst, $src"),
-      [(set GPRF64:$dst, (intr GPRF64:$src))]>;
-}
-
-multiclass UnaryIntrinsicDouble<ILOpCode opcode, Intrinsic intr>
-{
-def _f64 : OneInOneOut<opcode, (outs GPRF64:$dst),
-      (ins GPRF64:$src),
-      !strconcat(opcode.Text, " $dst, $src"),
-      [(set GPRF64:$dst, (intr GPRF64:$src))]>;
-def _v2f64 : OneInOneOut<opcode, (outs GPRV2F64:$dst),
-      (ins GPRV2F64:$src),
-      !strconcat(opcode.Text, " $dst, $src"),
-      [(set GPRV2F64:$dst, (intr GPRV2F64:$src))]>;
-}
-
-multiclass BinaryIntrinsicDouble<ILOpCode opcode, Intrinsic intr>
-{
-def _f64 : TwoInOneOut<opcode, (outs GPRF64:$dst),
-      (ins GPRF64:$src, GPRF64:$src2),
-      !strconcat(opcode.Text, " $dst, $src, $src2"),
-      [(set GPRF64:$dst,
-      (intr GPRF64:$src, GPRF64:$src2))]>;
-def _v2f64 : TwoInOneOut<opcode, (outs GPRV2F64:$dst),
-      (ins GPRV2F64:$src, GPRV2F64:$src2),
-      !strconcat(opcode.Text, " $dst, $src, $src2"),
-      [(set GPRV2F64:$dst,
-      (intr GPRV2F64:$src, GPRV2F64:$src2))]>;
-}
-
-multiclass TernaryIntrinsicDouble<ILOpCode opcode, Intrinsic intr>
-{
-def _f64 : TwoInOneOut<opcode, (outs GPRF64:$dst),
-      (ins GPRF64:$src, GPRF64:$src2, GPRF64:$src3),
-      !strconcat(opcode.Text, " $dst, $src, $src2, $src3"),
-      [(set GPRF64:$dst,
-      (intr GPRF64:$src, GPRF64:$src2, GPRF64:$src3))]>;
-def _v2f64 : TwoInOneOut<opcode, (outs GPRV2F64:$dst),
-      (ins GPRV2F64:$src, GPRV2F64:$src2, GPRV2F64:$src3),
-      !strconcat(opcode.Text, " $dst, $src, $src2, $src3"),
-      [(set GPRV2F64:$dst,
-      (intr GPRV2F64:$src, GPRV2F64:$src2, GPRV2F64:$src3))]>;
 }