[llvm-branch-commits] [llvm] [TableGen][AsmMatcher] Support CoerceFromRegClass for RegClassByHwMode (PR #241446)

Alexander Richardson via llvm-branch-commits llvm-branch-commits at lists.llvm.org
Fri Nov 13 17:15:22 PST 2026


https://github.com/arichardson updated https://github.com/llvm/llvm-project/pull/241446

>From c553f1e1f21bbbe746c86ae2d8d927502d098f1d Mon Sep 17 00:00:00 2001
From: Alex Richardson <alexrichardson at google.com>
Date: Thu, 12 Nov 2026 15:17:31 -0800
Subject: [PATCH] [nspr] initial commit

---
 .../TableGen/AsmMatcherCoerceFromRegClass.td  | 26 ++++++++++
 llvm/utils/TableGen/AsmMatcherEmitter.cpp     | 51 ++++++++++++++++---
 2 files changed, 69 insertions(+), 8 deletions(-)

diff --git a/llvm/test/TableGen/AsmMatcherCoerceFromRegClass.td b/llvm/test/TableGen/AsmMatcherCoerceFromRegClass.td
index d4c9112099b85..3366fcedd4b5b 100644
--- a/llvm/test/TableGen/AsmMatcherCoerceFromRegClass.td
+++ b/llvm/test/TableGen/AsmMatcherCoerceFromRegClass.td
@@ -42,6 +42,12 @@ def VRM2 : RegisterClass<"Arch", [v4i32], 128, (add V0M2, V2M2)> {
   let CoerceFromRegClass = VR;
 }
 
+/// Registers are only converted in the HwModes that select a class with
+/// CoerceFromRegClass.
+def IsCapMode : Predicate<"Subtarget->hasCapMode()">;
+def CapMode : HwMode<[IsCapMode]>;
+def PtrRC : RegClassByHwMode<[DefaultMode, CapMode], [GPR, YGPR]>;
+
 let Namespace = "Arch" in {
 def InstAnyGPR : Instruction {
   let OutOperandList = (outs AnyGPR:$rd);
@@ -60,6 +66,12 @@ def InstVRM2 : Instruction {
   let InOperandList = (ins VR:$vs);
   let AsmString = "vinst $vd, $vs";
 }
+
+def InstPtr : Instruction {
+  let OutOperandList = (outs GPR:$rd);
+  let InOperandList = (ins PtrRC:$ptr);
+  let AsmString = "zinst $rd, $ptr";
+}
 }
 
 #ifdef ERR_DUPLICATE_NAME
@@ -103,6 +115,20 @@ def BadRC : RegisterClass<"Arch", [i64], 64, (add R0_Y, R0)> {
 // CHECK-NEXT:    Inst.addOperand(MCOperand::createReg(Reg));
 // CHECK-NEXT:    break;
 // CHECK-NEXT:  }
+// CHECK-NEXT:  case CVT_95_convertToRegByHwMode_95_PtrRC:
+// CHECK-NEXT:    switch (STI->getHwMode(MCSubtargetInfo::HwMode_RegInfo)) {
+// CHECK-NEXT:    case 1: { // CapMode
+// CHECK-NEXT:      MCRegister Reg = Operands[OpIdx]->getReg();
+// CHECK-NEXT:      if (!getArchMCRegisterClass(Arch::YGPRRegClassID).contains(Reg))
+// CHECK-NEXT:        Reg = convertToYGPR(Reg);
+// CHECK-NEXT:      Inst.addOperand(MCOperand::createReg(Reg));
+// CHECK-NEXT:      break;
+// CHECK-NEXT:    }
+// CHECK-NEXT:    default:
+// CHECK-NEXT:      static_cast<ArchOperand &>(*Operands[OpIdx]).addRegOperands(Inst, 1);
+// CHECK-NEXT:      break;
+// CHECK-NEXT:    }
+// CHECK-NEXT:    break;
 
 /// Coerced YGPR and AnyGPR share MCK_AnyGPR because they match the same set of
 /// registers, whereas VRM2 gets its own MCK_VRM2 ({V0M2, V2M2, V0, V2}).
diff --git a/llvm/utils/TableGen/AsmMatcherEmitter.cpp b/llvm/utils/TableGen/AsmMatcherEmitter.cpp
index d3ce9c19d6999..38b270f0d5b35 100644
--- a/llvm/utils/TableGen/AsmMatcherEmitter.cpp
+++ b/llvm/utils/TableGen/AsmMatcherEmitter.cpp
@@ -2190,6 +2190,17 @@ static unsigned emitConvertFuncs(CodeGenTarget &Target, StringRef ClassName,
 
   // Register classes with CoerceFromRegClass that need a conversion function.
   SmallSetVector<const Record *, 8> CoercedRegClasses;
+  auto emitCoercedRegOperand = [&](const Record *RC, unsigned Indent) {
+    CoercedRegClasses.insert(RC);
+    CvtOS << indent(Indent) << "MCRegister Reg = Operands[OpIdx]->getReg();\n"
+          << indent(Indent) << "if (!get" << Target.getName()
+          << "MCRegisterClass("
+          << Target.getRegBank().getRegClass(RC)->getQualifiedIdName()
+          << ").contains(Reg))\n"
+          << indent(Indent + 2) << "Reg = convertTo" << RC->getName()
+          << "(Reg);\n"
+          << indent(Indent) << "Inst.addOperand(MCOperand::createReg(Reg));\n";
+  };
 
   for (auto &II : Info.Matchables) {
     // Check if we have a custom match function.
@@ -2242,6 +2253,14 @@ static unsigned emitConvertFuncs(CodeGenTarget &Target, StringRef ClassName,
         const Record *RegClass = Op.getRegClass();
         bool HasRegCoercion =
             RegClass && Info.RegConversions.contains(RegClass);
+        // For RegClassByHwMode operands: the HwModes that select a register
+        // class that needs coercion.
+        SmallVector<std::pair<unsigned, const Record *>, 0> HwModeCoercions;
+        if (RegClass && RegClass->isSubClassOf("RegClassByHwMode"))
+          for (auto [ModeId, ModeRC] :
+               Target.getHwModes().getHwModeSelect(RegClass).Items)
+            if (Info.RegConversions.contains(ModeRC))
+              HwModeCoercions.emplace_back(ModeId, ModeRC);
         // Registers are always converted the same unless they need to be
         // coerced, don't duplicate the conversion function based on them.
         std::string Class;
@@ -2249,6 +2268,9 @@ static unsigned emitConvertFuncs(CodeGenTarget &Target, StringRef ClassName,
         if (HasRegCoercion) {
           Class = RegClass->getName().str();
           Name += "convertTo" + Class;
+        } else if (!HwModeCoercions.empty()) {
+          Class = Op.Class->ClassName;
+          Name += "convertTo" + Class;
         } else if (Op.Class->isRegisterClass()) {
           Class = "Reg";
           Name += "Reg";
@@ -2299,14 +2321,27 @@ static unsigned emitConvertFuncs(CodeGenTarget &Target, StringRef ClassName,
                 << "      }\n";
         } else if (HasRegCoercion) {
           assert(OpInfo.MINumOperands == 1 && "Expected a single register");
-          CoercedRegClasses.insert(RegClass);
-          CvtOS
-              << "      MCRegister Reg = Operands[OpIdx]->getReg();\n"
-              << "      if (!get" << Target.getName() << "MCRegisterClass("
-              << Target.getRegBank().getRegClass(RegClass)->getQualifiedIdName()
-              << ").contains(Reg))\n"
-              << "        Reg = convertTo" << Class << "(Reg);\n"
-              << "      Inst.addOperand(MCOperand::createReg(Reg));\n";
+          emitCoercedRegOperand(RegClass, 6);
+        } else if (!HwModeCoercions.empty()) {
+          // Only convert the register in the HwModes that need it.
+          assert(OpInfo.MINumOperands == 1 && "Expected a single register");
+          CvtOS << "      switch "
+                   "(STI->getHwMode(MCSubtargetInfo::HwMode_RegInfo)) {\n";
+          for (auto [ModeId, ModeRC] : HwModeCoercions) {
+            CvtOS << "      case " << ModeId << ": { // "
+                  << Target.getHwModes().getModeName(ModeId,
+                                                     /*IncludeDefault=*/true)
+                  << "\n";
+            emitCoercedRegOperand(ModeRC, 8);
+            CvtOS << "        break;\n"
+                  << "      }\n";
+          }
+          CvtOS << "      default:\n"
+                << "        static_cast<" << TargetOperandClass
+                << " &>(*Operands[OpIdx])." << Op.Class->RenderMethod
+                << "(Inst, 1);\n"
+                << "        break;\n"
+                << "      }\n";
         } else {
           CvtOS << "      static_cast<" << TargetOperandClass
                 << " &>(*Operands[OpIdx])." << Op.Class->RenderMethod



More information about the llvm-branch-commits mailing list