[RISCV] Reorder masked builtin operands. Use clang_builtin_alias for all overloaded vector builtins.

[craig.topper]

Summary

This patch makes the builtin operand order match the C operand order
for all intrinsics. With this we can use clang_builtin_alias for
all overloaded intrinsics.

This should further reduce the test time for vector intrinsics.

[craig.topper]

clang/include/clang/Basic/riscv_vector.td

192

I remove this and added a couple ManualCodeGen blocks to permute builtin to IR intrinsics operand order to make up for it. I could have used PermuteOperands but then we would have had to translate it into C code to do the permutation in CGBuiltin.cpp.

[khchen]

LGTM. Thanks for improvement!

clang/include/clang/Basic/riscv_vector.td

192

Cool, using ManualCodeGen is more simple.

clang/include/clang/Basic/riscv_vector.td

class RVVBuiltin<string suffix, string prototype, string type_range,
   code ManualCodegenMask = [{}];
 
   // When emit the automatic clang codegen, it describes what types we have to use
   // to obtain the specific LLVM intrinsic. -1 means the return type, otherwise,
   // k >= 0 meaning the k-th operand (counting from zero) of the codegen'd
   // parameter of the unmasked version. k can't be the mask operand's position.
   list<int> IntrinsicTypes = [];
 
-  // When the order of the parameters of clang builtin do not match the order of
-  // C/C++ api, we use permutation index to mapping the operand from clang
-  // builtin to C/C++. It is parameter of the unmasked version without VL
-  // operand. If empty, the default permutation is [0, 1, 2, ...].
-  list<int> PermuteOperands = [];
-
   // If these names are not empty, this is the ID of the LLVM intrinsic
   // we want to lower to.
   string IRName = NAME;
 
   // If HasMask, this is the ID of the LLVM intrinsic we want to lower to.
   string IRNameMask = NAME #"_mask";
 
   // If non empty, this is the code emitted in the header, otherwise

 }
 
 let HasNoMaskedOverloaded = false,
     ManualCodegen = [{
       IntrinsicTypes = {ResultType, Ops[1]->getType()};
       Ops[0] = Builder.CreateBitCast(Ops[0], ResultType->getPointerTo());
     }],
     ManualCodegenMask= [{
+      // Move mask to right before vl.
+      std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
       IntrinsicTypes = {ResultType, Ops[3]->getType()};
       Ops[1] = Builder.CreateBitCast(Ops[1], ResultType->getPointerTo());
     }] in {
   class RVVVLEMaskBuiltin : RVVBuiltin<"m", "mPCUe", "c"> {
     let Name = "vle1_v";
     let IRName = "vle1";
     let HasMask = false;
   }
let Name = NAME # "_v",
             CGM.getNaturalTypeAlignment(getContext().getSizeType());
         Builder.CreateStore(Builder.CreateExtractValue(LoadValue, {1}),
                             Address(NewVL, Align));
         return V;
       }
       }],
       ManualCodegenMask = [{
       {
+        // Move mask to right before vl.
+        std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
         IntrinsicTypes = {ResultType, Ops[4]->getType()};
         Ops[1] = Builder.CreateBitCast(Ops[1], ResultType->getPointerTo());
         Value *NewVL = Ops[2];
         Ops.erase(Ops.begin() + 2);
         llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
         llvm::Value *LoadValue = Builder.CreateCall(F, Ops, "");
         llvm::Value *V = Builder.CreateExtractValue(LoadValue, {0});
         // Store new_vl.
let Name = NAME # "_v",
       IRName = "vlse",
       IRNameMask ="vlse_mask",
       HasNoMaskedOverloaded = false,
       ManualCodegen = [{
         IntrinsicTypes = {ResultType, Ops[2]->getType()};
         Ops[0] = Builder.CreateBitCast(Ops[0], ResultType->getPointerTo());
       }],
       ManualCodegenMask= [{
+        // Move mask to right before vl.
+        std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
         IntrinsicTypes = {ResultType, Ops[4]->getType()};
         Ops[1] = Builder.CreateBitCast(Ops[1], ResultType->getPointerTo());
       }] in {
     foreach type = types in {
       def : RVVBuiltin<"v", "vPCet", type>;
       if !not(IsFloat<type>.val) then {
         def : RVVBuiltin<"Uv", "UvPCUet", type>;
       }
     }
   }
 }
 
 multiclass RVVIndexedLoad<string op> {
   let ManualCodegen = [{
         IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType()};
         Ops[0] = Builder.CreateBitCast(Ops[0], ResultType->getPointerTo());
       }],
       ManualCodegenMask = [{
+        // Move mask to right before vl.
+        std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
         IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops[4]->getType()};
         Ops[1] = Builder.CreateBitCast(Ops[1], ResultType->getPointerTo());
       }] in {
       foreach type = TypeList in {
         foreach eew_list = EEWList in {
           defvar eew = eew_list[0];
           defvar eew_type = eew_list[1];
           let Name = op # eew # "_v", IRName = op, IRNameMask = op # "_mask" in {
             def: RVVBuiltin<"v", "vPCe" # eew_type # "Uv", type>;
               if !not(IsFloat<type>.val) then {
                 def: RVVBuiltin<"Uv", "UvPCUe" # eew_type # "Uv", type>;
               }
           }
         }
       }
   }
 }
 
 let HasMaskedOffOperand = false,
-    PermuteOperands = [1, 0], // C/C++ Operand: (ptr, value, vl). Builtin: (value, ptr, vl)
     ManualCodegen = [{
+      // Builtin: (ptr, value, vl). Intrinsic: (value, ptr, vl)
+      std::swap(Ops[0], Ops[1]);
       Ops[1] = Builder.CreateBitCast(Ops[1], Ops[0]->getType()->getPointerTo());
       IntrinsicTypes = {Ops[0]->getType(), Ops[2]->getType()};
     }],
     ManualCodegenMask= [{
+      // Builtin: (mask, ptr, value, vl). Intrinsic: (value, ptr, mask, vl)
+      std::swap(Ops[0], Ops[2]);
       Ops[1] = Builder.CreateBitCast(Ops[1], Ops[0]->getType()->getPointerTo());
       IntrinsicTypes = {Ops[0]->getType(), Ops[3]->getType()};
     }] in {
-  class RVVVSEMaskBuiltin : RVVBuiltin<"m", "0mPUe", "c"> {
+  class RVVVSEMaskBuiltin : RVVBuiltin<"m", "0PUem", "c"> {
     let Name = "vse1_v";
     let IRName = "vse1";
     let HasMask = false;
   }
   multiclass RVVVSEBuiltin<list<string> types> {
     let Name = NAME # "_v",
         IRName = "vse",
         IRNameMask = "vse_mask" in {
       foreach type = types in {
-        def : RVVBuiltin<"v", "0vPe", type>;
+        def : RVVBuiltin<"v", "0Pev", type>;
         if !not(IsFloat<type>.val) then {
-          def : RVVBuiltin<"Uv", "0UvPUe", type>;
+          def : RVVBuiltin<"Uv", "0PUeUv", type>;
         }
       }
     }
   }
 }
 
 multiclass RVVVSSEBuiltin<list<string> types> {
   let Name = NAME # "_v",
       IRName = "vsse",
       IRNameMask = "vsse_mask",
       HasMaskedOffOperand = false,
-      PermuteOperands = [1, 2, 0], // C/C++ Operand: (ptr, stride, value, vl). Builtin: (value, ptr, stride, vl)
       ManualCodegen = [{
+        // Builtin: (ptr, stride, value, vl). Intrinsic: (value, ptr, stride, vl)
+        std::rotate(Ops.begin(), Ops.begin() + 2, Ops.begin() + 3);
         Ops[1] = Builder.CreateBitCast(Ops[1], Ops[0]->getType()->getPointerTo());
         IntrinsicTypes = {Ops[0]->getType(), Ops[3]->getType()};
       }],
       ManualCodegenMask= [{
+        // Builtin: (mask, ptr, stride, value, vl). Intrinsic: (value, ptr, stride, mask, vl)
+        std::swap(Ops[0], Ops[3]);
         Ops[1] = Builder.CreateBitCast(Ops[1], Ops[0]->getType()->getPointerTo());
         IntrinsicTypes = {Ops[0]->getType(), Ops[4]->getType()};
       }] in {
     foreach type = types in {
-      def : RVVBuiltin<"v", "0vPet", type>;
+      def : RVVBuiltin<"v", "0Petv", type>;
       if !not(IsFloat<type>.val) then {
-        def : RVVBuiltin<"Uv", "0UvPUet", type>;
+        def : RVVBuiltin<"Uv", "0PUetUv", type>;
       }
     }
   }
 }
 
 multiclass RVVIndexedStore<string op> {
   let HasMaskedOffOperand = false,
-      PermuteOperands = [1, 2, 0], // C/C++ Operand: (ptr, index, value, vl). Builtin: (value, ptr, index, vl)
       ManualCodegen = [{
+        // Builtin: (ptr, index, value, vl). Intrinsic: (value, ptr, index, vl)
+        std::rotate(Ops.begin(), Ops.begin() + 2, Ops.begin() + 3);
         Ops[1] = Builder.CreateBitCast(Ops[1],Ops[0]->getType()->getPointerTo());
         IntrinsicTypes = {Ops[0]->getType(), Ops[2]->getType(), Ops[3]->getType()};
       }],
       ManualCodegenMask= [{
+        // Builtin: (mask, ptr, index, value, vl). Intrinsic: (value, ptr, index, mask, vl)
+        std::swap(Ops[0], Ops[3]);
         Ops[1] = Builder.CreateBitCast(Ops[1], Ops[0]->getType()->getPointerTo());
         IntrinsicTypes = {Ops[0]->getType(), Ops[2]->getType(), Ops[4]->getType()};
       }] in {
       foreach type = TypeList in {
         foreach eew_list = EEWList in {
           defvar eew = eew_list[0];
           defvar eew_type = eew_list[1];
           let Name = op # eew  # "_v", IRName = op, IRNameMask = op # "_mask" in  {
-            def : RVVBuiltin<"v", "0vPe" # eew_type # "Uv", type>;
+            def : RVVBuiltin<"v", "0Pe" # eew_type # "Uvv", type>;
             if !not(IsFloat<type>.val) then {
-              def : RVVBuiltin<"Uv", "0UvPUe" # eew_type # "Uv", type>;
+              def : RVVBuiltin<"Uv", "0PUe" # eew_type # "UvUv", type>;
             }
           }
         }
       }
   }
 }
 
 multiclass RVVAMOBuiltinSet<bit has_signed = false, bit has_unsigned = false,
                             bit has_fp = false> {
   defvar type_list = !if(has_fp, ["i","l","f","d"], ["i","l"]);
   foreach type = type_list in
     foreach eew_list = EEWList in {
       defvar eew = eew_list[0];
       defvar eew_index = eew_list[1];
       let Name = NAME # "ei" # eew # "_" # "v",
           IRName = NAME,
           IRNameMask = NAME # "_mask",
           HasMaskedOffOperand = false,
           ManualCodegen = [{
             // base, bindex, value, vl
             IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[3]->getType()};
             Ops[0] = Builder.CreateBitCast(Ops[0], ResultType->getPointerTo());
           }],
           ManualCodegenMask = [{
+            std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
             IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[4]->getType()};
             Ops[0] = Builder.CreateBitCast(Ops[0], ResultType->getPointerTo());
           }] in {
         if has_signed then
           def : RVVBuiltin<"v", "vPe" # eew_index # "Uvv", type>;
         if !and(!not(IsFloat<type>.val), has_unsigned) then
           def : RVVBuiltin<"Uv", "UvPUe" # eew_index # "UvUv", type>;
       }
let Name = NAME,
                           cast<llvm::VectorType>(ResultType)->getElementType(),
                           Ops[1]->getType()};
         Ops.insert(Ops.begin() + 1, llvm::Constant::getNullValue(IntrinsicTypes[1]));
         break;
       }
       }],
       ManualCodegenMask = [{
       {
+        std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
         // maskedoff, op1, mask, vl
         IntrinsicTypes = {ResultType,
                           cast<llvm::VectorType>(ResultType)->getElementType(),
                           Ops[3]->getType()};
         Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(IntrinsicTypes[1]));
         break;
       }
       }] in {
let Name = NAME,
                           Ops[1]->getType()};
         Ops.insert(Ops.begin() + 1,
                    llvm::Constant::getAllOnesValue(IntrinsicTypes[1]));
         break;
       }
       }],
       ManualCodegenMask = [{
       {
+        std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
         // maskedoff, op1, mask, vl
         IntrinsicTypes = {ResultType,
                           cast<llvm::VectorType>(ResultType)->getElementType(),
                           Ops[3]->getType()};
         Ops.insert(Ops.begin() + 2,
                    llvm::Constant::getAllOnesValue(IntrinsicTypes[1]));
         break;
       }
let Name = NAME,
         IntrinsicTypes = {ResultType,
                           Ops[0]->getType(), Ops[1]->getType()};
         Ops.insert(Ops.begin() + 1, Ops[0]);
         break;
       }
       }],
       ManualCodegenMask = [{
       {
+        std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
         // maskedoff, op1, mask, vl
         IntrinsicTypes = {ResultType,
                           Ops[1]->getType(),
                           Ops[3]->getType()};
         Ops.insert(Ops.begin() + 2, Ops[1]);
         break;
       }
       }] in {
let Name = NAME,
                           cast<llvm::VectorType>(Ops[0]->getType())->getElementType(),
                           Ops[1]->getType()};
         Ops.insert(Ops.begin() + 1, llvm::Constant::getNullValue(IntrinsicTypes[2]));
         break;
       }
       }],
       ManualCodegenMask = [{
       {
+        std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
         // maskedoff, op1, mask, vl
         IntrinsicTypes = {ResultType,
                           Ops[1]->getType(),
                           cast<llvm::VectorType>(Ops[1]->getType())->getElementType(),
                           Ops[3]->getType()};
         Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(IntrinsicTypes[2]));
         break;
       }
let Name = NAME,
                           Ops[1]->getType(),
                           Ops[1]->getType()};
         Ops.insert(Ops.begin() + 1, llvm::Constant::getNullValue(IntrinsicTypes[2]));
         break;
       }
       }],
       ManualCodegenMask = [{
       {
+        std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
         // maskedoff, op1, mask, vl
         IntrinsicTypes = {ResultType,
                           Ops[1]->getType(),
                           Ops[3]->getType(),
                           Ops[3]->getType()};
         Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(IntrinsicTypes[2]));
         break;
       }

 defm vwmaccsu : RVVOutOp1Op2BuiltinSet<"vwmaccsu", "csi",
                                        [["vv", "w", "wwvUv"],
                                         ["vx", "w", "wweUv"]]>;
 defm vwmaccus : RVVOutOp1Op2BuiltinSet<"vwmaccus", "csi",
                                        [["vx", "w", "wwUev"]]>;
 }
 
 // 12.15. Vector Integer Merge Instructions
-// C/C++ Operand: (mask, op1, op2, vl), Builtin: (op1, op2, mask, vl)
-let HasMask = false, PermuteOperands = [2, 0, 1] in {
-  defm vmerge : RVVCarryinBuiltinSet;
+// C/C++ Operand: (mask, op1, op2, vl), Intrinsic: (op1, op2, mask, vl)
+let HasMask = false,
+    ManualCodegen = [{
+      std::rotate(Ops.begin(), Ops.begin() + 1, Ops.begin() + 3);
+      IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[3]->getType()};
+    }] in {
+  defm vmerge : RVVOutOp1BuiltinSet<"vmerge", "csil",
+                                    [["vvm", "v", "vmvv"],
+                                     ["vxm", "v", "vmve"],
+                                     ["vvm", "Uv", "UvmUvUv"],
+                                     ["vxm", "Uv", "UvmUvUe"]]>;
 }
 
 // 12.16. Vector Integer Move Instructions
 let HasMask = false in {
   let MangledName = "vmv_v" in {
     defm vmv_v : RVVOutBuiltinSet<"vmv_v_v", "csil",
                                    [["v", "Uv", "UvUv"]]>;
     defm vmv_v : RVVOutBuiltinSet<"vmv_v_v", "csilfd",

 defm vmfge : RVVFloatingMaskOutBuiltinSet;
 
 // 14.14. Vector Floating-Point Classify Instruction
 let Name = "vfclass_v" in
   def vfclass : RVVOp0Builtin<"Uv", "Uvv", "fd">;
 
 // 14.15. Vector Floating-Point Merge Instructio
 // C/C++ Operand: (mask, op1, op2, vl), Builtin: (op1, op2, mask, vl)
-let HasMask = false, PermuteOperands = [2, 0, 1] in {
+let HasMask = false,
+    ManualCodegen = [{
+      std::rotate(Ops.begin(), Ops.begin() + 1, Ops.begin() + 3);
+      IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[3]->getType()};
+    }] in {
   defm vmerge : RVVOutOp1BuiltinSet<"vfmerge", "fd",
-                                    [["vvm", "v", "vvvm"]]>;
+                                    [["vvm", "v", "vmvv"]]>;
   defm vfmerge : RVVOutOp1BuiltinSet<"vfmerge", "fd",
-                                    [["vfm", "v", "vvem"]]>;
+                                    [["vfm", "v", "vmve"]]>;
 }
 
 // 14.16. Vector Floating-Point Move Instruction
 let HasMask = false, HasNoMaskedOverloaded = false in
   defm vfmv_v : RVVOutBuiltinSet<"vfmv_v_f", "fd",
                                   [["f", "v", "ve"]]>;
 
 // 14.17. Single-Width Floating-Point/Integer Type-Convert Instructions

 defm vrgather : RVVOutBuiltinSet<"vrgather_vv", "csil",
                                  [["vv", "Uv", "UvUvUv"]]>;
 defm vrgather : RVVOutBuiltinSet<"vrgather_vx", "csil",
                                  [["vx", "Uv", "UvUvz"]]>;
 defm vrgatherei16 : RVVOutBuiltinSet<"vrgatherei16_vv", "csil",
                                      [["vv", "Uv", "UvUv(Log2EEW:4)Uv"]]>;
 
 // 17.5. Vector Compress Instruction
-let HasMask = false, PermuteOperands = [2, 0, 1] in {
+let HasMask = false,
+    ManualCodegen = [{
+      std::rotate(Ops.begin(), Ops.begin() + 1, Ops.begin() + 3);
+      ID = Intrinsic::riscv_vcompress;
+       IntrinsicTypes = {ResultType, Ops[3]->getType()};
+    }] in {
   // signed and floating type
   defm vcompress : RVVOutBuiltinSet<"vcompress", "csilfd",
-                                    [["vm", "v", "vvvm"]]>;
+                                    [["vm", "v", "vmvv"]]>;
   // unsigned type
   defm vcompress : RVVOutBuiltinSet<"vcompress", "csil",
-                                    [["vm", "Uv", "UvUvUvm"]]>;
+                                    [["vm", "Uv", "UvmUvUv"]]>;
 }
 
 // Miscellaneous
 let HasMask = false, HasVL = false, HasNoMaskedOverloaded = false,
     IRName = "" in {
   let Name = "vreinterpret_v",
       ManualCodegen = [{
         return Builder.CreateBitCast(Ops[0], ResultType);