[RISCV] Merge Masked and unMasked RVV manual codegen

[BeMg]

Summary

RVV intrinsic function will generate riscv_vector_builtin_cg.inc for CGBuiltin.cpp to produce the corresponding RVV intrinsic LLVM IR.

In this stage, riscv_vector.td will describe the bunch of manual codegen C++ code to tell CGBuiltin how to handle these instructions.

In this patch, we merge the masked RVV manual codegen and unmasked RVV manual codegen to reduce the number of manual codegen, and make more policy addition easier in the future.

This is a clean-up job that will not affect the RVV intrinsic functionality.

[BeMg]

Update format

[craig.topper]

clang/include/clang/Basic/riscv_vector.td

629–640

space after if

648

space after if

712–718

space after if

720–723

space after if

Drop the curly brace since the bodies are single lines

751–757

space after if

759–762

Space after if

Drop the curly braces since the bodies are single lines

1224–1235

Space after if

1273

Indentation looks wrong. The body is only indented once space from the else.

[BeMg]

Update format

[BeMg]

Update format

[kito-cheng]

LGTM, thanks for clean up this!

[BeMg]

Update format

[BeMg]

rebase

clang/include/clang/Basic/riscv_vector.td

class RVVBuiltin<string suffix, string prototype, string type_range,
   // suffix `_tu`, `tumu`, `tuma`, `tamu` and `tama`.
   bit SupportOverloading = true;
 
   // This builtin is valid for the given Log2LMULs.
   list<int> Log2LMUL = [0, 1, 2, 3, -1, -2, -3];
 
   // Manual code in clang codegen riscv_vector_builtin_cg.inc
   code ManualCodegen = [{}];
-  code MaskedManualCodegen = [{}];
 
   // 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 = [];
 
   // If these names are not empty, this is the ID of the LLVM intrinsic

 multiclass RVVVLEFFBuiltin<list<string> types> {
   let Name = NAME # "_v",
       IRName = "vleff",
       MaskedIRName = "vleff_mask",
       SupportOverloading = false,
       UnMaskedPolicyScheme = HasPassthruOperand,
       ManualCodegen = [{
       {
-        if (DefaultPolicy == TAIL_AGNOSTIC)
-          Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
-        IntrinsicTypes = {ResultType, Ops[3]->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.
-        clang::CharUnits Align =
-            CGM.getNaturalPointeeTypeAlignment(E->getArg(1)->getType());
-        llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {1});
-        Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
-        return V;
-      }
-      }],
-      MaskedManualCodegen = [{
-      {
+        if (IsMasked) {
           // Move mask to right before vl.
           std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
           if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
             Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
           Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
           IntrinsicTypes = {ResultType, Ops[4]->getType()};
+        } else {
+          if (DefaultPolicy == TAIL_AGNOSTIC)
+            Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
+          IntrinsicTypes = {ResultType, Ops[3]->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.
-        clang::CharUnits Align = CGM.getNaturalPointeeTypeAlignment(
-            E->getArg(E->getNumArgs()-2)->getType());
+        clang::CharUnits Align;
+        if (IsMasked)
+          Align = CGM.getNaturalPointeeTypeAlignment(E->getArg(E->getNumArgs()-2)->getType());
+        else
+          Align = CGM.getNaturalPointeeTypeAlignment(E->getArg(1)->getType());
         llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {1});
         Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
         return V;
       }
       }] in {
     foreach type = types in {
       def : RVVBuiltin<"v", "vPCePz", type>;
       // Skip floating types for unsigned versions.
foreach type = TypeList in {
         }
     }
   }
 }
 
 let HasMaskedOffOperand = false,
     MaskedPolicyScheme = NonePolicy,
     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()};
-    }],
-    MaskedManualCodegen= [{
+      if (IsMasked) {
         // Builtin: (mask, ptr, value, vl). Intrinsic: (value, ptr, mask, vl)
         std::swap(Ops[0], Ops[2]);
+      } else {
+        // Builtin: (ptr, value, vl). Intrinsic: (value, ptr, vl)
+        std::swap(Ops[0], Ops[1]);
+      }
       Ops[1] = Builder.CreateBitCast(Ops[1], Ops[0]->getType()->getPointerTo());
+      if (IsMasked)
         IntrinsicTypes = {Ops[0]->getType(), Ops[3]->getType()};
+      else
+        IntrinsicTypes = {Ops[0]->getType(), Ops[2]->getType()};
     }] in {
   class RVVVSEMaskBuiltin : RVVBuiltin<"m", "0PUem", "c"> {
     let Name = "vsm_v";
     let IRName = "vsm";
     let HasMasked = false;
   }
   multiclass RVVVSEBuiltin<list<string> types> {
     let Name = NAME # "_v",

 
 multiclass RVVVSSEBuiltin<list<string> types> {
   let Name = NAME # "_v",
       IRName = "vsse",
       MaskedIRName = "vsse_mask",
       HasMaskedOffOperand = false,
       MaskedPolicyScheme = NonePolicy,
       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()};
-      }],
-      MaskedManualCodegen= [{
+        if (IsMasked) {
           // Builtin: (mask, ptr, stride, value, vl). Intrinsic: (value, ptr, stride, mask, vl)
           std::swap(Ops[0], Ops[3]);
+        } else {
+          // 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());
+        if (IsMasked)
           IntrinsicTypes = {Ops[0]->getType(), Ops[4]->getType()};
+        else
+          IntrinsicTypes = {Ops[0]->getType(), Ops[3]->getType()};
       }] in {
     foreach type = types in {
       def : RVVBuiltin<"v", "0Petv", type>;
       if !not(IsFloat<type>.val) then {
         def : RVVBuiltin<"Uv", "0PUetUv", type>;
       }
     }
   }
 }
 
 multiclass RVVIndexedStore<string op> {
   let HasMaskedOffOperand = false,
       MaskedPolicyScheme = NonePolicy,
       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()};
-      }],
-      MaskedManualCodegen= [{
+        if (IsMasked) {
           // Builtin: (mask, ptr, index, value, vl). Intrinsic: (value, ptr, index, mask, vl)
           std::swap(Ops[0], Ops[3]);
+        } else {
+          // 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());
+        if (IsMasked)
           IntrinsicTypes = {Ops[0]->getType(), Ops[2]->getType(), Ops[4]->getType()};
+        else
+          IntrinsicTypes = {Ops[0]->getType(), Ops[2]->getType(), Ops[3]->getType()};
       }] in {
       foreach type = TypeList in {
         foreach eew_list = EEWList[0-2] in {
           defvar eew = eew_list[0];
           defvar eew_type = eew_list[1];
           let Name = op # eew  # "_v", IRName = op, MaskedIRName = op # "_mask" in  {
             def : RVVBuiltin<"v", "0Pe" # eew_type # "Uvv", type>;
             if !not(IsFloat<type>.val) then {
defvar eew = !cond(!eq(type, "c") : "8",
       foreach nf = NFList in {
         let Name = op # nf # "e" # eew # "_v",
             IRName = op # nf,
             MaskedIRName = op # nf # "_mask",
             NF = nf,
             ManualCodegen = [{
     {
       ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
-      // TA builtin: (val0 address, val1 address, ..., ptr, vl)
-      // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
       IntrinsicTypes = {ResultType, Ops.back()->getType()};
-      // intrinsic: (passthru0, passthru1, ..., ptr, vl)
       SmallVector<llvm::Value*, 10> Operands;
-      if (DefaultPolicy == TAIL_AGNOSTIC) {
-        for (unsigned I = 0; I < NF; ++I)
-          Operands.push_back(llvm::PoisonValue::get(ResultType));
-        Operands.push_back(Ops[NF]);
-        Operands.push_back(Ops[NF + 1]);
-      } else {
-        for (unsigned I = 0; I < NF; ++I)
-          Operands.push_back(Ops[NF + I]);
-        Operands.push_back(Ops[2 * NF]);
-        Operands.push_back(Ops[2 * NF + 1]);
-      }
-      llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
-      llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
-      clang::CharUnits Align =
-          CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
-      llvm::Value *V;
-      for (unsigned I = 0; I < NF; ++I) {
-        llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
-        V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
-      }
-      return V;
-    }
-            }],
-            MaskedManualCodegen = [{
-    {
+      if (IsMasked) {
         // TAMA builtin: (val0 address, ..., mask, ptr, vl)
         // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
         // intrinsic: (maskedoff0, ..., ptr, mask, vl)
-      ResultType =  ConvertType(E->getArg(0)->getType()->getPointeeType());
-      IntrinsicTypes = {ResultType, Ops.back()->getType()};
-      SmallVector<llvm::Value*, 12> Operands;
         if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
           for (unsigned I = 0; I < NF; ++I)
             Operands.push_back(llvm::PoisonValue::get(ResultType));
           Operands.push_back(Ops[NF + 1]);
           Operands.push_back(Ops[NF]);
           Operands.push_back(Ops[NF + 2]);
         } else {
           for (unsigned I = 0; I < NF; ++I)
             Operands.push_back(Ops[NF + I + 1]);
           Operands.push_back(Ops[2 * NF + 1]);
           Operands.push_back(Ops[NF]);
           Operands.push_back(Ops[2 * NF + 2]);
         }
         Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
         assert(Operands.size() == NF + 4);
+      } else {
+        // TA builtin: (val0 address, val1 address, ..., ptr, vl)
+        // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
+        // intrinsic: (passthru0, passthru1, ..., ptr, vl)
+        if (DefaultPolicy == TAIL_AGNOSTIC) {
+          for (unsigned I = 0; I < NF; ++I)
+            Operands.push_back(llvm::PoisonValue::get(ResultType));
+          Operands.push_back(Ops[NF]);
+          Operands.push_back(Ops[NF + 1]);
+        } else {
+          for (unsigned I = 0; I < NF; ++I)
+            Operands.push_back(Ops[NF + I]);
+          Operands.push_back(Ops[2 * NF]);
+          Operands.push_back(Ops[2 * NF + 1]);
+        }
+      }
       llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
       llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
       clang::CharUnits Align =
           CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
       llvm::Value *V;
       for (unsigned I = 0; I < NF; ++I) {
         llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
         V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
       }
       return V;
     }
-            }] in {
           defvar PV = PVString<nf, /*signed=*/true>.S;
           defvar PUV = PVString<nf, /*signed=*/false>.S;
           def : RVVBuiltin<"v", "0" # PV # "PCe", type>;
           if !not(IsFloat<type>.val) then {
             def : RVVBuiltin<"Uv", "0" # PUV # "PCUe", type>;
         }
       }
     }
defvar eew = !cond(!eq(type, "c") : "8",
                        !eq(type, "d") : "64");
       foreach nf = NFList in {
         let Name = op # nf # "e" # eew # "ff_v",
             IRName = op # nf # "ff",
             MaskedIRName = op # nf # "ff_mask",
             NF = nf,
             ManualCodegen = [{
     {
-      // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
-      // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
       ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
       IntrinsicTypes = {ResultType, Ops.back()->getType()};
-      // intrinsic: (passthru0, passthru1, ..., ptr, vl)
       SmallVector<llvm::Value*, 12> Operands;
       Value *NewVL;
-      if (DefaultPolicy == TAIL_AGNOSTIC) {
-        for (unsigned I = 0; I < NF; ++I)
-          Operands.push_back(llvm::PoisonValue::get(ResultType));
-        Operands.push_back(Ops[NF]);
-        Operands.push_back(Ops[NF + 2]);
-        NewVL = Ops[NF + 1];
-      } else {
-        for (unsigned I = 0; I < NF; ++I)
-          Operands.push_back(Ops[NF + I]);
-        Operands.push_back(Ops[2 * NF]);
-        Operands.push_back(Ops[2 * NF + 2]);
-        NewVL = Ops[2 * NF + 1];
-      }
-      llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
-      llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
-      clang::CharUnits Align =
-          CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
-      for (unsigned I = 0; I < NF; ++I) {
-        llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
-        Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
-      }
-      // Store new_vl.
-      llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
-      return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
-    }
-            }],
-            MaskedManualCodegen = [{
-    {
+
+      if (IsMasked) {
         // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
         // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
         // intrinsic: (maskedoff0, ..., ptr, mask, vl)
-      ResultType =  ConvertType(E->getArg(0)->getType()->getPointeeType());
-      IntrinsicTypes = {ResultType, Ops.back()->getType()};
-      SmallVector<llvm::Value*, 12> Operands;
-      Value *NewVL;
         if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
           for (unsigned I = 0; I < NF; ++I)
             Operands.push_back(llvm::PoisonValue::get(ResultType));
           Operands.push_back(Ops[NF + 1]);
           Operands.push_back(Ops[NF]);
           Operands.push_back(Ops[NF + 3]);
           NewVL = Ops[NF + 2];
         } else {
           for (unsigned I = 0; I < NF; ++I)
             Operands.push_back(Ops[NF + I + 1]);
           Operands.push_back(Ops[2 * NF + 1]);
           Operands.push_back(Ops[NF]);
           Operands.push_back(Ops[2 * NF + 3]);
           NewVL = Ops[2 * NF + 2];
         }
         Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
         assert(Operands.size() == NF + 4);
+      } else {
+        // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
+        // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
+        // intrinsic: (passthru0, passthru1, ..., ptr, vl)
+        if (DefaultPolicy == TAIL_AGNOSTIC) {
+          for (unsigned I = 0; I < NF; ++I)
+            Operands.push_back(llvm::PoisonValue::get(ResultType));
+          Operands.push_back(Ops[NF]);
+          Operands.push_back(Ops[NF + 2]);
+          NewVL = Ops[NF + 1];
+        } else {
+          for (unsigned I = 0; I < NF; ++I)
+            Operands.push_back(Ops[NF + I]);
+          Operands.push_back(Ops[2 * NF]);
+          Operands.push_back(Ops[2 * NF + 2]);
+          NewVL = Ops[2 * NF + 1];
+        }
+      }
       llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
       llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
       clang::CharUnits Align =
           CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
       for (unsigned I = 0; I < NF; ++I) {
         llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
         Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
       }
       // Store new_vl.
       llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
       return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
     }
-            }] in {
           defvar PV = PVString<nf, /*signed=*/true>.S;
           defvar PUV = PVString<nf, /*signed=*/false>.S;
           def : RVVBuiltin<"v", "0" # PV # "PCe" # "Pz", type>;
           if !not(IsFloat<type>.val) then {
             def : RVVBuiltin<"Uv", "0" # PUV # "PCUe" # "Pz", type>;
         }
       }
     }
defvar eew = !cond(!eq(type, "c") : "8",
                        !eq(type, "d") : "64");
       foreach nf = NFList in {
         let Name = op # nf # "e" # eew # "_v",
             IRName = op # nf,
             MaskedIRName = op # nf # "_mask",
             NF = nf,
             ManualCodegen = [{
     {
-      // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
-      // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
       ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
       IntrinsicTypes = {ResultType, Ops.back()->getType()};
-      // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
       SmallVector<llvm::Value*, 12> Operands;
-      if (DefaultPolicy == TAIL_AGNOSTIC) {
-        for (unsigned I = 0; I < NF; ++I)
-          Operands.push_back(llvm::PoisonValue::get(ResultType));
-        Operands.push_back(Ops[NF]);
-        Operands.push_back(Ops[NF + 1]);
-        Operands.push_back(Ops[NF + 2]);
-      } else {
-        for (unsigned I = 0; I < NF; ++I)
-          Operands.push_back(Ops[NF + I]);
-        Operands.push_back(Ops[2 * NF]);
-        Operands.push_back(Ops[2 * NF + 1]);
-        Operands.push_back(Ops[2 * NF + 2]);
-      }
-      llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
-      llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
-      clang::CharUnits Align =
-          CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
-      llvm::Value *V;
-      for (unsigned I = 0; I < NF; ++I) {
-        llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
-        V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
-      }
-      return V;
-    }
-            }],
-            MaskedManualCodegen = [{
-    {
-      //TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
+
+      if (IsMasked) {
+        // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
         // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
         // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
-      ResultType =  ConvertType(E->getArg(0)->getType()->getPointeeType());
-      IntrinsicTypes = {ResultType, Ops.back()->getType()};
-      SmallVector<llvm::Value*, 12> Operands;
         if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
           for (unsigned I = 0; I < NF; ++I)
             Operands.push_back(llvm::PoisonValue::get(ResultType));
           Operands.push_back(Ops[NF + 1]);
           Operands.push_back(Ops[NF + 2]);
           Operands.push_back(Ops[NF]);
           Operands.push_back(Ops[NF + 3]);
         } else {
           for (unsigned I = 0; I < NF; ++I)
             Operands.push_back(Ops[NF + I + 1]);
           Operands.push_back(Ops[2 * NF + 1]);
           Operands.push_back(Ops[2 * NF + 2]);
           Operands.push_back(Ops[NF]);
           Operands.push_back(Ops[2 * NF + 3]);
         }
         Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
         assert(Operands.size() == NF + 5);
+      } else {
+        // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
+        // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
+        // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
+        if (DefaultPolicy == TAIL_AGNOSTIC) {
+          for (unsigned I = 0; I < NF; ++I)
+            Operands.push_back(llvm::PoisonValue::get(ResultType));
+          Operands.push_back(Ops[NF]);
+          Operands.push_back(Ops[NF + 1]);
+          Operands.push_back(Ops[NF + 2]);
+        } else {
+          for (unsigned I = 0; I < NF; ++I)
+            Operands.push_back(Ops[NF + I]);
+          Operands.push_back(Ops[2 * NF]);
+          Operands.push_back(Ops[2 * NF + 1]);
+          Operands.push_back(Ops[2 * NF + 2]);
+        }
+      }
       llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
       llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
       clang::CharUnits Align =
           CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
       llvm::Value *V;
       for (unsigned I = 0; I < NF; ++I) {
         llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
         V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
       }
       return V;
     }
-            }] in {
           defvar PV = PVString<nf, /*signed=*/true>.S;
           defvar PUV = PVString<nf, /*signed=*/false>.S;
           def : RVVBuiltin<"v", "0" # PV # "PCe" # "t", type>;
           if !not(IsFloat<type>.val) then {
             def : RVVBuiltin<"Uv", "0" # PUV # "PCUe" # "t", type>;
         }
       }
     }
   }
 }
 
 multiclass RVVIndexedSegLoad<string op> {
   foreach type = TypeList in {
     foreach eew_info = EEWList in {
       defvar eew = eew_info[0];
       defvar eew_type = eew_info[1];
       foreach nf = NFList in {
         let Name = op # nf # "ei" # eew # "_v",
             IRName = op # nf,
             MaskedIRName = op # nf # "_mask",
             NF = nf,
             ManualCodegen = [{
     {
-      // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
-      // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
       ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
-      // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
       SmallVector<llvm::Value*, 12> Operands;
-      if (DefaultPolicy == TAIL_AGNOSTIC) {
-        for (unsigned I = 0; I < NF; ++I)
-          Operands.push_back(llvm::PoisonValue::get(ResultType));
-        Operands.push_back(Ops[NF]);
-        Operands.push_back(Ops[NF + 1]);
-        Operands.push_back(Ops[NF + 2]);
-        IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
-      } else {
-        for (unsigned I = 0; I < NF; ++I)
-          Operands.push_back(Ops[NF + I]);
-        Operands.push_back(Ops[2 * NF]);
-        Operands.push_back(Ops[2 * NF + 1]);
-        Operands.push_back(Ops[2 * NF + 2]);
-        IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
-      }
-      llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
-      llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
-      clang::CharUnits Align =
-          CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
-      llvm::Value *V;
-      for (unsigned I = 0; I < NF; ++I) {
-        llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
-        V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
-      }
-      return V;
-    }
-            }],
-            MaskedManualCodegen = [{
-    {
+      if (IsMasked) {
         // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
         // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
-      ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
         // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
-      SmallVector<llvm::Value*, 12> Operands;
         if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
           for (unsigned I = 0; I < NF; ++I)
             Operands.push_back(llvm::PoisonValue::get(ResultType));
           Operands.push_back(Ops[NF + 1]);
           Operands.push_back(Ops[NF + 2]);
           Operands.push_back(Ops[NF]);
           Operands.push_back(Ops[NF + 3]);
           IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
         } else {
           for (unsigned I = 0; I < NF; ++I)
             Operands.push_back(Ops[NF + I + 1]);
           Operands.push_back(Ops[2 * NF + 1]);
           Operands.push_back(Ops[2 * NF + 2]);
           Operands.push_back(Ops[NF]);
           Operands.push_back(Ops[2 * NF + 3]);
           IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
         }
         Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
         assert(Operands.size() == NF + 5);
+      } else {
+        // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
+        // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
+        // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
+        if (DefaultPolicy == TAIL_AGNOSTIC) {
+          for (unsigned I = 0; I < NF; ++I)
+            Operands.push_back(llvm::PoisonValue::get(ResultType));
+          Operands.push_back(Ops[NF]);
+          Operands.push_back(Ops[NF + 1]);
+          Operands.push_back(Ops[NF + 2]);
+          IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
+        } else {
+          for (unsigned I = 0; I < NF; ++I)
+            Operands.push_back(Ops[NF + I]);
+          Operands.push_back(Ops[2 * NF]);
+          Operands.push_back(Ops[2 * NF + 1]);
+          Operands.push_back(Ops[2 * NF + 2]);
+          IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
+        }
+      }
       llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
       llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
       clang::CharUnits Align =
           CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
       llvm::Value *V;
       for (unsigned I = 0; I < NF; ++I) {
         llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
         V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
       }
       return V;
     }
-            }] in {
           defvar PV = PVString<nf, /*signed=*/true>.S;
           defvar PUV = PVString<nf, /*signed=*/false>.S;
           def : RVVBuiltin<"v", "0" # PV # "PCe" # eew_type # "Uv", type>;
           if !not(IsFloat<type>.val) then {
             def : RVVBuiltin<"Uv", "0" # PUV # "PCUe" # eew_type # "Uv", type>;
           }
         }
       }
defvar eew = !cond(!eq(type, "c") : "8",
         let Name = op # nf # "e" # eew # "_v",
             IRName = op # nf,
             MaskedIRName = op # nf # "_mask",
             NF = nf,
             HasMaskedOffOperand = false,
             MaskedPolicyScheme = NonePolicy,
             ManualCodegen = [{
     {
-      // Builtin: (ptr, val0, val1, ..., vl)
-      // Intrinsic: (val0, val1, ..., ptr, vl)
-      std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
-      IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 1]->getType()};
-      assert(Ops.size() == NF + 2);
-    }
-            }],
-            MaskedManualCodegen = [{
-    {
+      if (IsMasked) {
         // Builtin: (mask, ptr, val0, val1, ..., vl)
         // Intrinsic: (val0, val1, ..., ptr, mask, vl)
         std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
         std::swap(Ops[NF], Ops[NF + 1]);
         IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 2]->getType()};
         assert(Ops.size() == NF + 3);
+      } else {
+        // Builtin: (ptr, val0, val1, ..., vl)
+        // Intrinsic: (val0, val1, ..., ptr, vl)
+        std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
+        IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 1]->getType()};
+        assert(Ops.size() == NF + 2);
+      }
     }
             }] in {
           defvar V = VString<nf, /*signed=*/true>.S;
           defvar UV = VString<nf, /*signed=*/false>.S;
           def : RVVBuiltin<"v", "0Pe" # V, type>;
           if !not(IsFloat<type>.val) then {
             def : RVVBuiltin<"Uv", "0PUe" # UV, type>;
         }
defvar eew = !cond(!eq(type, "c") : "8",
         let Name = op # nf # "e" # eew # "_v",
             IRName = op # nf,
             MaskedIRName = op # nf # "_mask",
             NF = nf,
             HasMaskedOffOperand = false,
             MaskedPolicyScheme = NonePolicy,
             ManualCodegen = [{
     {
+      if (IsMasked) {
+        // Builtin: (mask, ptr, stride, val0, val1, ..., vl).
+        // Intrinsic: (val0, val1, ..., ptr, stride, mask, vl)
+        std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
+        std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
+        assert(Ops.size() == NF + 4);
+      } else {
         // Builtin: (ptr, stride, val0, val1, ..., vl).
         // Intrinsic: (val0, val1, ..., ptr, stride, vl)
         std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
-      IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 1]->getType()};
         assert(Ops.size() == NF + 3);
       }
-            }],
-            MaskedManualCodegen = [{
-    {
-      // Builtin: (mask, ptr, stride, val0, val1, ..., vl).
-      // Intrinsic: (val0, val1, ..., ptr, stride, mask, vl)
-      std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
-      std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
       IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 1]->getType()};
-      assert(Ops.size() == NF + 4);
     }
             }] in {
           defvar V = VString<nf, /*signed=*/true>.S;
           defvar UV = VString<nf, /*signed=*/false>.S;
           def : RVVBuiltin<"v", "0Pet" # V, type>;
           if !not(IsFloat<type>.val) then {
             def : RVVBuiltin<"Uv", "0PUet" # UV, type>;
         }
foreach eew_info = EEWList in {
         let Name = op # nf # "ei" # eew # "_v",
             IRName = op # nf,
             MaskedIRName = op # nf # "_mask",
             NF = nf,
             HasMaskedOffOperand = false,
             MaskedPolicyScheme = NonePolicy,
             ManualCodegen = [{
     {
-      // Builtin: (ptr, index, val0, val1, ..., vl)
-      // Intrinsic: (val0, val1, ..., ptr, index, vl)
-      std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
-      IntrinsicTypes = {Ops[0]->getType(),
-                        Ops[NF + 1]->getType(), Ops[NF + 2]->getType()};
-      assert(Ops.size() == NF + 3);
-    }
-            }],
-            MaskedManualCodegen = [{
-    {
+      if (IsMasked) {
         // Builtin: (mask, ptr, index, val0, val1, ..., vl)
         // Intrinsic: (val0, val1, ..., ptr, index, mask, vl)
         std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
         std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
         IntrinsicTypes = {Ops[0]->getType(),
                           Ops[NF + 1]->getType(), Ops[NF + 3]->getType()};
         assert(Ops.size() == NF + 4);
+      } else {
+        // Builtin: (ptr, index, val0, val1, ..., vl)
+        // Intrinsic: (val0, val1, ..., ptr, index, vl)
+        std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
+        IntrinsicTypes = {Ops[0]->getType(),
+                          Ops[NF + 1]->getType(), Ops[NF + 2]->getType()};
+        assert(Ops.size() == NF + 3);
+      }
     }
             }] in {
           defvar V = VString<nf, /*signed=*/true>.S;
           defvar UV = VString<nf, /*signed=*/false>.S;
           def : RVVBuiltin<"v", "0Pe" # eew_type # "Uv" # V, type>;
           if !not(IsFloat<type>.val) then {
             def : RVVBuiltin<"Uv", "0PUe" # eew_type # "Uv" # UV, type>;
           }
         }
       }
     }
   }
 }
 
 multiclass RVVPseudoUnaryBuiltin<string IR, string type_range> {
   let Name = NAME,
       IRName = IR,
       MaskedIRName = IR # "_mask",
       UnMaskedPolicyScheme = HasPassthruOperand,
       ManualCodegen = [{
       {
-        if (DefaultPolicy == TAIL_AGNOSTIC)
-          Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
-        auto ElemTy = cast<llvm::VectorType>(ResultType)->getElementType();
-        Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(ElemTy));
-        // passthru, op1, op2, vl
-        IntrinsicTypes = {ResultType, ElemTy, Ops[3]->getType()};
-        break;
-      }
-      }],
-      MaskedManualCodegen = [{
-      {
+        if (IsMasked) {
           std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
           if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
             Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
+        } else {
+          if (DefaultPolicy == TAIL_AGNOSTIC)
+            Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
+        }
         auto ElemTy = cast<llvm::VectorType>(ResultType)->getElementType();
         Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(ElemTy));
+
+        if (IsMasked) {
           Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
           // maskedoff, op1, op2, mask, vl, policy
           IntrinsicTypes = {ResultType, ElemTy, Ops[4]->getType()};
+        } else {
+          // passthru, op1, op2, vl
+          IntrinsicTypes = {ResultType, ElemTy, Ops[3]->getType()};
+        }
         break;
       }
       }] in {
         def : RVVBuiltin<"v", "vv", type_range>;
   }
 }
 
 multiclass RVVPseudoVNotBuiltin<string IR, string type_range> {
   let Name = NAME,
       IRName = IR,
       MaskedIRName = IR # "_mask",
       UnMaskedPolicyScheme = HasPassthruOperand,
       ManualCodegen = [{
       {
-        if (DefaultPolicy == TAIL_AGNOSTIC)
-          Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
-        auto ElemTy = cast<llvm::VectorType>(ResultType)->getElementType();
-        Ops.insert(Ops.begin() + 2,
-                   llvm::Constant::getAllOnesValue(ElemTy));
-        // passthru, op1, op2, vl
-        IntrinsicTypes = {ResultType,
-                          ElemTy,
-                          Ops[3]->getType()};
-        break;
-      }
-      }],
-      MaskedManualCodegen = [{
-      {
+        if (IsMasked) {
           std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
           if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
             Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
+        } else {
+          if (DefaultPolicy == TAIL_AGNOSTIC)
+            Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
+        }
         auto ElemTy = cast<llvm::VectorType>(ResultType)->getElementType();
         Ops.insert(Ops.begin() + 2,
                    llvm::Constant::getAllOnesValue(ElemTy));
+        if (IsMasked) {
           Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
           // maskedoff, op1, po2, mask, vl, policy
           IntrinsicTypes = {ResultType,
                             ElemTy,
                             Ops[4]->getType()};
+        } else {
+          // passthru, op1, op2, vl
+          IntrinsicTypes = {ResultType,
+                            ElemTy,
+                            Ops[3]->getType()};
+        }
         break;
       }
       }] in {
         def : RVVBuiltin<"v", "vv", type_range>;
         def : RVVBuiltin<"Uv", "UvUv", type_range>;
   }
 }
 

 
 multiclass RVVPseudoVFUnaryBuiltin<string IR, string type_range> {
   let Name = NAME,
       IRName = IR,
       MaskedIRName = IR # "_mask",
       UnMaskedPolicyScheme = HasPassthruOperand,
       ManualCodegen = [{
       {
-        if (DefaultPolicy == TAIL_AGNOSTIC)
-          Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
-        // op1, po2, vl
-        IntrinsicTypes = {ResultType,
-                          Ops[1]->getType(), Ops[2]->getType()};
-        Ops.insert(Ops.begin() + 2, Ops[1]);
-        break;
-      }
-      }],
-      MaskedManualCodegen = [{
-      {
+        if (IsMasked) {
           std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
           if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
             Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
           Ops.insert(Ops.begin() + 2, Ops[1]);
           Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
           // maskedoff, op1, op2, mask, vl
           IntrinsicTypes = {ResultType,
                             Ops[2]->getType(),
                             Ops.back()->getType()};
+        } else {
+          if (DefaultPolicy == TAIL_AGNOSTIC)
+            Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
+          // op1, po2, vl
+          IntrinsicTypes = {ResultType,
+                            Ops[1]->getType(), Ops[2]->getType()};
+          Ops.insert(Ops.begin() + 2, Ops[1]);
+          break;
+        }
         break;
       }
       }] in {
         def : RVVBuiltin<"v", "vv", type_range>;
   }
 }
 
 multiclass RVVPseudoVWCVTBuiltin<string IR, string MName, string type_range,
                                  list<list<string>> suffixes_prototypes> {
   let Name = NAME,
       OverloadedName = MName,
       IRName = IR,
       MaskedIRName = IR # "_mask",
       UnMaskedPolicyScheme = HasPassthruOperand,
       ManualCodegen = [{
       {
-        if (DefaultPolicy == TAIL_AGNOSTIC)
-          Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
-        auto ElemTy = cast<llvm::VectorType>(ResultType)->getElementType();
-        Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(ElemTy));
-        // passtru, op1, op2, vl
-        IntrinsicTypes = {ResultType,
-                          Ops[1]->getType(),
-                          ElemTy,
-                          Ops[3]->getType()};
-        break;
-      }
-      }],
-      MaskedManualCodegen = [{
-      {
+        if (IsMasked) {
           std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
           if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
             Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
+        } else {
+          if (DefaultPolicy == TAIL_AGNOSTIC)
+            Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
+        }
         auto ElemTy = cast<llvm::VectorType>(ResultType)->getElementType();
         Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(ElemTy));
+        if (IsMasked) {
           Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
           // maskedoff, op1, op2, mask, vl, policy
           IntrinsicTypes = {ResultType,
                             Ops[1]->getType(),
                             ElemTy,
                             Ops[4]->getType()};
+        } else {
+          // passtru, op1, op2, vl
+          IntrinsicTypes = {ResultType,
+                            Ops[1]->getType(),
+                            ElemTy,
+                            Ops[3]->getType()};
+        }
         break;
       }
       }] in {
         foreach s_p = suffixes_prototypes in {
           def : RVVBuiltin<s_p[0], s_p[1], type_range>;
         }
   }
 }
 
 multiclass RVVPseudoVNCVTBuiltin<string IR, string MName, string type_range,
                                  list<list<string>> suffixes_prototypes> {
   let Name = NAME,
       OverloadedName = MName,
       IRName = IR,
       MaskedIRName = IR # "_mask",
       UnMaskedPolicyScheme = HasPassthruOperand,
       ManualCodegen = [{
       {
-        if (DefaultPolicy == TAIL_AGNOSTIC)
-          Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
-        Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(Ops.back()->getType()));
-        // passthru, op1, xlen, vl
-        IntrinsicTypes = {ResultType,
-                          Ops[1]->getType(),
-                          Ops[3]->getType(),
-                          Ops[3]->getType()};
-        break;
-      }
-      }],
-      MaskedManualCodegen = [{
-      {
+        if (IsMasked) {
           std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
           if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
             Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
-        Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(Ops.back()->getType()));
+        } else {
+          if (DefaultPolicy == TAIL_AGNOSTIC)
+            Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
+        }
+        Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(Ops.back()->getType())); 
+        if (IsMasked) {
           Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
           // maskedoff, op1, xlen, mask, vl
           IntrinsicTypes = {ResultType,
                             Ops[1]->getType(),
                             Ops[4]->getType(),
                             Ops[4]->getType()};
+        } else {
+          // passthru, op1, xlen, vl
+          IntrinsicTypes = {ResultType,
+                  Ops[1]->getType(),
+                  Ops[3]->getType(),
+                  Ops[3]->getType()};
+        }
         break;
       }
       }] in {
         foreach s_p = suffixes_prototypes in {
           def : RVVBuiltin<s_p[0], s_p[1], type_range>;
         }
   }
 }

clang/lib/CodeGen/CGBuiltin.cpp

Value *CodeGenFunction::EmitRISCVBuiltinExpr(unsigned BuiltinID,
   }
 
   Intrinsic::ID ID = Intrinsic::not_intrinsic;
   unsigned NF = 1;
   constexpr unsigned TAIL_UNDISTURBED = 0;
   constexpr unsigned TAIL_AGNOSTIC = 1;
   constexpr unsigned TAIL_AGNOSTIC_MASK_AGNOSTIC = 3;
   int DefaultPolicy = TAIL_UNDISTURBED;
+  bool IsMasked = false;
 
   // Required for overloaded intrinsics.
   llvm::SmallVector<llvm::Type *, 2> IntrinsicTypes;
   switch (BuiltinID) {
   default: llvm_unreachable("unexpected builtin ID");
   case RISCV::BI__builtin_riscv_orc_b_32:
   case RISCV::BI__builtin_riscv_orc_b_64:
   case RISCV::BI__builtin_riscv_clz_32:

clang/utils/TableGen/RISCVVEmitter.cpp

void emitCodeGenSwitchBody(const RVVIntrinsic *RVVI, raw_ostream &OS) {
   // We had initialized DefaultPolicy as TU/TUMU in CodeGen function.
   if (!RVVI->getDefaultPolicy().isTUPolicy() &&
       !RVVI->getDefaultPolicy().isTUMUPolicy() && !RVVI->hasPassthruOperand() &&
       !RVVI->hasManualCodegen() && RVVI->hasVL())
     OS << "  DefaultPolicy = " << RVVI->getDefaultPolicyBits() << ";\n";
 
   if (RVVI->hasManualCodegen()) {
     OS << "  DefaultPolicy = " << RVVI->getDefaultPolicyBits() << ";\n";
+    if (RVVI->isMasked())
+      OS << "IsMasked = true;\n";
+    else
+      OS << "IsMasked = false;\n";
     OS << RVVI->getManualCodegen();
     OS << "break;\n";
     return;
   }
 
   // Cast pointer operand of vector load intrinsic.
   for (const auto &I : enumerate(RVVI->getInputTypes())) {
     if (I.value()->isPointer()) {
auto UnMaskedPolicyScheme =
         static_cast<PolicyScheme>(UMPSRecord->getValueAsInt("Value"));
     std::vector<int64_t> Log2LMULList = R->getValueAsListOfInts("Log2LMUL");
     bool HasTailPolicy = R->getValueAsBit("HasTailPolicy");
     bool HasMaskPolicy = R->getValueAsBit("HasMaskPolicy");
     bool IsPrototypeDefaultTU = R->getValueAsBit("IsPrototypeDefaultTU");
     bool SupportOverloading = R->getValueAsBit("SupportOverloading");
     bool HasBuiltinAlias = R->getValueAsBit("HasBuiltinAlias");
     StringRef ManualCodegen = R->getValueAsString("ManualCodegen");
-    StringRef MaskedManualCodegen = R->getValueAsString("MaskedManualCodegen");
     std::vector<int64_t> IntrinsicTypes =
         R->getValueAsListOfInts("IntrinsicTypes");
     std::vector<StringRef> RequiredFeatures =
         R->getValueAsListOfStrings("RequiredFeatures");
     StringRef IRName = R->getValueAsString("IRName");
     StringRef MaskedIRName = R->getValueAsString("MaskedIRName");
     unsigned NF = R->getValueAsInt("NF");
 
for (char I : TypeRange) {
         if (!HasMasked)
           continue;
         // Create a masked intrinsic
         Optional<RVVTypes> MaskTypes =
             TypeCache.computeTypes(BT, Log2LMUL, NF, Prototype);
         Out.push_back(std::make_unique<RVVIntrinsic>(
             Name, SuffixStr, OverloadedName, OverloadedSuffixStr, MaskedIRName,
             /*IsMasked=*/true, HasMaskedOffOperand, HasVL, MaskedPolicyScheme,
-            SupportOverloading, HasBuiltinAlias, MaskedManualCodegen,
+            SupportOverloading, HasBuiltinAlias, ManualCodegen,
             *MaskTypes, IntrinsicTypes, RequiredFeatures, NF,
             Policy(), IsPrototypeDefaultTU));
         if (MaskedPolicyScheme == PolicyScheme::SchemeNone)
           continue;
         for (auto P : SupportedMaskedPolicies) {
           SmallVector<PrototypeDescriptor> PolicyPrototype =
               RVVIntrinsic::computeBuiltinTypes(
                   BasicPrototype, /*IsMasked=*/true, HasMaskedOffOperand, HasVL,
                   NF, IsPrototypeDefaultTU, MaskedPolicyScheme, P);
           Optional<RVVTypes> PolicyTypes =
               TypeCache.computeTypes(BT, Log2LMUL, NF, PolicyPrototype);
           Out.push_back(std::make_unique<RVVIntrinsic>(
               Name, SuffixStr, OverloadedName, OverloadedSuffixStr,
               MaskedIRName, /*IsMasked=*/true, HasMaskedOffOperand, HasVL,
               MaskedPolicyScheme, SupportOverloading, HasBuiltinAlias,
-              MaskedManualCodegen, *PolicyTypes, IntrinsicTypes,
+              ManualCodegen, *PolicyTypes, IntrinsicTypes,
               RequiredFeatures, NF, P, IsPrototypeDefaultTU));
         }
       } // End for Log2LMULList
     }   // End for TypeRange
 
     // We don't emit vsetvli and vsetvlimax for SemaRecord.
     // They are written in riscv_vector.td and will emit those marco define in
     // riscv_vector.h