[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