[llvm-branch-commits] [llvm] [TableGen][AsmMatcher] Support custom RenderMethod on RegisterClass (PR #242126)

Alexander Richardson via llvm-branch-commits llvm-branch-commits at lists.llvm.org
Tue Nov 17 18:49:20 PST 2026


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

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

---
 llvm/include/llvm/Target/Target.td            |  7 ++-
 .../TableGen/AsmMatcherCoerceFromRegClass.td  | 37 +++++++++++
 llvm/test/TableGen/RegClassByHwMode.td        | 28 ++++++++-
 llvm/utils/TableGen/AsmMatcherEmitter.cpp     | 62 ++++++++++++++-----
 4 files changed, 115 insertions(+), 19 deletions(-)

diff --git a/llvm/include/llvm/Target/Target.td b/llvm/include/llvm/Target/Target.td
index 208ebf8ec56098..9a8cb911ed78eb 100644
--- a/llvm/include/llvm/Target/Target.td
+++ b/llvm/include/llvm/Target/Target.td
@@ -282,7 +282,12 @@ class DAGOperand {
 /// RegClassByHwMode. This permits using RegClassByHwMode in
 /// RegisterOperand contexts without creating an artificial
 /// RegisterClass.
-class RegisterClassLike : DAGOperand;
+class RegisterClassLike : DAGOperand {
+  // Method on the target's MCParsedAsmOperand class used to add MCInst
+  // operands for this register class. If not set, this defaults to
+  // "addRegOperands".
+  string RenderMethod = ?;
+}
 
 // RegisterClass - Now that all of the registers are defined, and aliases
 // between registers are defined, specify which registers belong to which
diff --git a/llvm/test/TableGen/AsmMatcherCoerceFromRegClass.td b/llvm/test/TableGen/AsmMatcherCoerceFromRegClass.td
index f2ae243922830c..5df94252611d4f 100644
--- a/llvm/test/TableGen/AsmMatcherCoerceFromRegClass.td
+++ b/llvm/test/TableGen/AsmMatcherCoerceFromRegClass.td
@@ -1,6 +1,9 @@
 // RUN: llvm-tblgen -gen-asm-matcher -I %p/../../include %s | FileCheck %s
 // RUN: not llvm-tblgen -gen-asm-matcher -I %p/../../include %s -DERR_DUPLICATE_NAME 2>&1 | FileCheck %s --check-prefix=ERR-DUPLICATE-NAME
 // RUN: not llvm-tblgen -gen-asm-matcher -I %p/../../include %s -DERR_SHADOWED 2>&1 | FileCheck %s --check-prefix=ERR-SHADOWED
+// RUN: not llvm-tblgen -gen-asm-matcher -I %p/../../include %s -DERR_RENDER_METHOD 2>&1 | FileCheck %s --check-prefix=ERR-RENDER-METHOD
+// RUN: not llvm-tblgen -gen-asm-matcher -I %p/../../include %s -DERR_RENDER_METHOD_CONFLICT 2>&1 | FileCheck %s --check-prefix=ERR-RENDER-METHOD-CONFLICT
+// RUN: not llvm-tblgen -gen-asm-matcher -I %p/../../include %s -DERR_RENDER_METHOD_COERCE_CONFLICT 2>&1 | FileCheck %s --check-prefix=ERR-RENDER-METHOD-COERCE-CONFLICT
 
 include "llvm/Target/Target.td"
 
@@ -169,6 +172,40 @@ def BadRC : RegisterClass<"Arch", [i32], 32, (add R0, R1)> {
 // ERR-SHADOWED: error: RegisterClass 'BadRC' cannot coerce from 'R0_Y' since MatchRegisterName returns 'R0' for 'r0'
 #endif
 
+#ifdef ERR_RENDER_METHOD
+def BadRC : RegisterClass<"Arch", [i64], 64, (add R0_Y)> {
+  let RenderMethod = "addCustomRegOperands";
+  let CoerceFromRegClass = GPR;
+}
+// ERR-RENDER-METHOD: error: RegisterClass 'BadRC' cannot specify both 'RenderMethod' and 'CoerceFromRegClass'
+#endif
+
+/// Register classes with the same registers share a match class, so they must
+/// use the same RenderMethod.
+#ifdef ERR_RENDER_METHOD_CONFLICT
+def BadRC : RegisterClass<"Arch", [i32], 32, (add R0, R1)> {
+  let RenderMethod = "addCustomRegOperands";
+}
+// ERR-RENDER-METHOD-CONFLICT: error: RegisterClass 'GPR' has the same registers as 'BadRC' but a different RenderMethod
+#endif
+
+/// The same applies to classes that match the same registers as a class with
+/// CoerceFromRegClass, since those always use the default RenderMethod.
+#ifdef ERR_RENDER_METHOD_COERCE_CONFLICT
+let Namespace = "Arch" in {
+  def R2 : Register<"r2">;
+  def R2_Y : Register<"r2">;
+}
+def GPR2 : RegisterClass<"Arch", [i32], 32, (add R2)>;
+def YGPR2 : RegisterClass<"Arch", [i64], 64, (add R2_Y)> {
+  let CoerceFromRegClass = GPR2;
+}
+def BadRC : RegisterClass<"Arch", [i64], 64, (add R2_Y, R2)> {
+  let RenderMethod = "addCustomRegOperands";
+}
+// ERR-RENDER-METHOD-COERCE-CONFLICT: error: RegisterClass 'YGPR2' has the same registers as 'BadRC' but a different RenderMethod
+#endif
+
 // CHECK-LABEL: static MCRegister convertToUPR(MCRegister Reg) {
 // CHECK-NEXT:    assert(Reg.id() >= Arch::U0 && Reg.id() <= Arch::U4 &&
 // CHECK-NEXT:           (Reg.id() - Arch::U0) % 2 == 0 && "unexpected register");
diff --git a/llvm/test/TableGen/RegClassByHwMode.td b/llvm/test/TableGen/RegClassByHwMode.td
index f9623f87f03450..4614dad90fbd5a 100644
--- a/llvm/test/TableGen/RegClassByHwMode.td
+++ b/llvm/test/TableGen/RegClassByHwMode.td
@@ -81,6 +81,28 @@ include "Common/RegClassByHwModeCommon.td"
 // INSTRINFO: #endif // GET_INSTRINFO_HEADER
 
 
+// ASMMATCHER: void MyTargetAsmParser::
+// ASMMATCHER-NEXT: convertToMCInst(
+// ASMMATCHER: case CVT_95_convertToRegByHwMode_95_XRegs_95_EvenIfRequired:
+// ASMMATCHER-NEXT: switch (STI->getHwMode(MCSubtargetInfo::HwMode_RegInfo)) {
+// ASMMATCHER-NEXT: case 1: // EvenMode
+// ASMMATCHER-NEXT: static_cast<MyTargetOperand &>(*Operands[OpIdx]).addEvenRegOperands(Inst, 1);
+// ASMMATCHER-NEXT: break;
+// ASMMATCHER-NEXT: default:
+// ASMMATCHER-NEXT: static_cast<MyTargetOperand &>(*Operands[OpIdx]).addRegOperands(Inst, 1);
+// ASMMATCHER-NEXT: break;
+// ASMMATCHER-NEXT: }
+// ASMMATCHER-NEXT: break;
+// ASMMATCHER-NEXT: case CVT_95_addRegOperands:
+// ASMMATCHER-NEXT: static_cast<MyTargetOperand &>(*Operands[OpIdx]).addRegOperands(Inst, 1);
+// ASMMATCHER-NEXT: break;
+// ASMMATCHER-NEXT: case CVT_95_Reg:
+// ASMMATCHER-NEXT: static_cast<MyTargetOperand &>(*Operands[OpIdx]).addRegOperands(Inst, 1);
+// ASMMATCHER-NEXT: break;
+// ASMMATCHER-NEXT: case CVT_95_addEvenRegOperands:
+// ASMMATCHER-NEXT: static_cast<MyTargetOperand &>(*Operands[OpIdx]).addEvenRegOperands(Inst, 1);
+// ASMMATCHER-NEXT: break;
+
 // ASMMATCHER: enum MatchClassKind {
 // ASMMATCHER:   MCK_LAST_TOKEN = OptionalMatchClass,
 // ASMMATCHER-NEXT:   MCK_XRegs_Odd, // register class 'XRegs_Odd'
@@ -145,7 +167,7 @@ include "Common/RegClassByHwModeCommon.td"
 // ASMMATCHER: /* also_my_load_1 */, MyTarget::MY_LOAD, Convert__RegByHwMode_XRegs_EvenIfRequired1_0__RegByHwMode_MyPtrRC1_1, AMFBS_None, { MCK_RegByHwMode_XRegs_EvenIfRequired, MCK_RegByHwMode_MyPtrRC }, },
 // ASMMATCHER: /* also_my_load_2 */, MyTarget::MY_LOAD, Convert__RegByHwMode_XRegs_EvenIfRequired1_0__RegByHwMode_MyPtrRC1_1, AMFBS_None, { MCK_RegByHwMode_XRegs_EvenIfRequired, MCK_RegByHwMode_MyPtrRC }, },
 // ASMMATCHER: /* always_all */, MyTarget::ALWAYS_ALL, Convert__Reg1_0, AMFBS_None, { MCK_XRegs }, },
-// ASMMATCHER: /* always_even */, MyTarget::ALWAYS_EVEN, Convert__Reg1_0, AMFBS_None, { MCK_XRegs_Even }, },
+// ASMMATCHER: /* always_even */, MyTarget::ALWAYS_EVEN, Convert__XRegs_Even1_0, AMFBS_None, { MCK_XRegs_Even }, },
 // ASMMATCHER: /* custom_decode */, MyTarget::CUSTOM_DECODE, Convert__RegByHwMode_YRegs_EvenIfRequired1_0, AMFBS_None, { MCK_RegByHwMode_YRegs_EvenIfRequired }, },
 // ASMMATCHER: /* even_if_mode */, MyTarget::EVEN_IF_MODE, Convert__RegByHwMode_XRegs_EvenIfRequired1_0, AMFBS_None, { MCK_RegByHwMode_XRegs_EvenIfRequired }, },
 // ASMMATCHER: /* my_mov */, MyTarget::MY_MOV, Convert__RegByHwMode_YRegs_EvenIfRequired1_0__RegByHwMode_XRegs_EvenIfRequired1_1, AMFBS_None, { MCK_RegByHwMode_YRegs_EvenIfRequired, MCK_RegByHwMode_XRegs_EvenIfRequired }, },
@@ -320,7 +342,9 @@ def P3_64 : MyReg<"p3_64">;
 
 
 def XRegs_Odd : RegisterClass<"MyTarget", [i64], 64, (add X1, X3, X5)>;
-def XRegs_Even : RegisterClass<"MyTarget", [i64], 64, (add X0, X2, X4, X6)>;
+def XRegs_Even : RegisterClass<"MyTarget", [i64], 64, (add X0, X2, X4, X6)> {
+  let RenderMethod = "addEvenRegOperands";
+}
 
 def XRegs_EvenIfRequired : RegClassByHwMode<[DefaultMode, EvenMode, OddMode],
                                             [XRegs, XRegs_Even, XRegs_Odd]>;
diff --git a/llvm/utils/TableGen/AsmMatcherEmitter.cpp b/llvm/utils/TableGen/AsmMatcherEmitter.cpp
index ffe891d78df5b5..2ea396df53effa 100644
--- a/llvm/utils/TableGen/AsmMatcherEmitter.cpp
+++ b/llvm/utils/TableGen/AsmMatcherEmitter.cpp
@@ -154,6 +154,9 @@ class AsmMatcherEmitter {
   void run(raw_ostream &o);
 };
 
+/// The RenderMethod used for register classes that don't specify one.
+static constexpr StringLiteral DefaultRegRenderMethod = "addRegOperands";
+
 /// ClassInfo - Helper class for storing the information about a particular
 /// class of operands which can be matched.
 struct ClassInfo {
@@ -205,7 +208,7 @@ struct ClassInfo {
   bool PredicateUsesSubtarget = false;
 
   /// RenderMethod - The name of the operand method to add this operand to an
-  /// MCInst; this is not valid for Token or register kinds.
+  /// MCInst; this is not valid for Token kinds.
   std::string RenderMethod;
 
   /// ParserMethod - The name of the operand method to do a target specific
@@ -1349,6 +1352,10 @@ void AsmMatcherInfo::buildRegisterClasses(
     const Record *Def = RC.getDef();
     if (!Def || Def->isValueUnset("CoerceFromRegClass"))
       continue;
+    if (!Def->isValueUnset("RenderMethod"))
+      PrintFatalError(Def->getLoc(), "RegisterClass '" + RC.getName() +
+                                         "' cannot specify both 'RenderMethod' "
+                                         "and 'CoerceFromRegClass'");
     DenseMap<StringRef, const Record *> RegsByAsmName;
     for (const Record *Reg : RC.getOrder()) {
       StringRef AsmName = Reg->getValueAsString("AsmName");
@@ -1437,7 +1444,7 @@ void AsmMatcherInfo::buildRegisterClasses(
     CI->Name = "MCK_Reg" + utostr(Index);
     CI->ValueName = "";
     CI->PredicateMethod = ""; // unused
-    CI->RenderMethod = "addRegOperands";
+    CI->RenderMethod = DefaultRegRenderMethod;
     CI->Registers = RS;
     // FIXME: diagnostic type.
     CI->DiagnosticType = "";
@@ -1464,11 +1471,19 @@ void AsmMatcherInfo::buildRegisterClasses(
     if (!Def)
       continue;
     ClassInfo *CI = RegisterSetClasses[GetRegisterSet(RC)];
+    StringRef RenderMethod = Def->getValueAsOptionalString("RenderMethod")
+                                 .value_or(DefaultRegRenderMethod);
     if (CI->ValueName.empty()) {
       CI->ClassName = RC.getName();
       CI->Name = "MCK_" + RC.getName();
       CI->ValueName = RC.getName();
+      CI->RenderMethod = RenderMethod.str();
     } else {
+      if (CI->RenderMethod != RenderMethod)
+        PrintFatalError(Def->getLoc(), "RegisterClass '" + RC.getName() +
+                                           "' has the same registers as '" +
+                                           CI->ClassName +
+                                           "' but a different RenderMethod");
       CI->ValueName = CI->ValueName + "," + RC.getName();
     }
 
@@ -1497,7 +1512,8 @@ void AsmMatcherInfo::buildRegisterClasses(
     CI.ClassName = "RegByHwMode_" + ClassByHwMode->getName().str();
     CI.Name = "MCK_" + CI.ClassName;
     CI.ValueName = ClassByHwMode->getName();
-    CI.RenderMethod = "addRegOperands";
+    CI.RenderMethod = ClassByHwMode->getValueAsOptionalString("RenderMethod")
+                          .value_or(DefaultRegRenderMethod);
     //  FIXME: Set diagnostic type.
     ++RegClassByHwModeIndex;
 
@@ -2312,24 +2328,28 @@ static unsigned emitConvertFuncs(CodeGenTarget &Target, StringRef ClassName,
         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;
+        // class that needs coercion or a different RenderMethod.
+        SmallVector<std::pair<unsigned, const Record *>, 0> HwModeConversions;
         if (RegClass && RegClass->isSubClassOf("RegClassByHwMode"))
           for (auto [ModeId, ModeRC] :
                Target.getHwModes().getHwModeSelect(RegClass).Items)
-            if (Info.RegConversions.contains(ModeRC))
-              HwModeCoercions.emplace_back(ModeId, ModeRC);
+            if (Info.RegConversions.contains(ModeRC) ||
+                Info.RegisterClassClasses.at(ModeRC)->RenderMethod !=
+                    Op.Class->RenderMethod)
+              HwModeConversions.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.
+        // coerced or use a custom RenderMethod, don't duplicate the conversion
+        // function based on them.
         std::string Class;
         std::string Name = "CVT_";
         if (HasRegCoercion) {
           Class = RegClass->getName().str();
           Name += "convertTo" + Class;
-        } else if (!HwModeCoercions.empty()) {
+        } else if (!HwModeConversions.empty()) {
           Class = Op.Class->ClassName;
           Name += "convertTo" + Class;
-        } else if (Op.Class->isRegisterClass()) {
+        } else if (Op.Class->isRegisterClass() &&
+                   Op.Class->RenderMethod == DefaultRegRenderMethod) {
           Class = "Reg";
           Name += "Reg";
         } else {
@@ -2380,19 +2400,29 @@ static unsigned emitConvertFuncs(CodeGenTarget &Target, StringRef ClassName,
         } else if (HasRegCoercion) {
           assert(OpInfo.MINumOperands == 1 && "Expected a single register");
           emitCoercedRegOperand(RegClass, 6);
-        } else if (!HwModeCoercions.empty()) {
+        } else if (!HwModeConversions.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 << ": { // "
+          for (auto [ModeId, ModeRC] : HwModeConversions) {
+            bool Coerce = Info.RegConversions.contains(ModeRC);
+            CvtOS << "      case " << ModeId << ":" << (Coerce ? " {" : "")
+                  << " // "
                   << Target.getHwModes().getModeName(ModeId,
                                                      /*IncludeDefault=*/true)
                   << "\n";
-            emitCoercedRegOperand(ModeRC, 8);
-            CvtOS << "        break;\n"
-                  << "      }\n";
+            if (Coerce) {
+              emitCoercedRegOperand(ModeRC, 8);
+            } else {
+              CvtOS << "        static_cast<" << TargetOperandClass
+                    << " &>(*Operands[OpIdx])."
+                    << Info.RegisterClassClasses.at(ModeRC)->RenderMethod
+                    << "(Inst, 1);\n";
+            }
+            CvtOS << "        break;\n";
+            if (Coerce)
+              CvtOS << "      }\n";
           }
           CvtOS << "      default:\n"
                 << "        static_cast<" << TargetOperandClass



More information about the llvm-branch-commits mailing list