[llvm-branch-commits] [llvm] [TableGen][AsmMatcher] Emit arithmetic for linear register coercion. NFCI (PR #241974)

Alexander Richardson via llvm-branch-commits llvm-branch-commits at lists.llvm.org
Tue Nov 17 14:53:51 PST 2026


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

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

---
 .../TableGen/AsmMatcherCoerceFromRegClass.td  | 48 +++++++++++---
 llvm/utils/TableGen/AsmMatcherEmitter.cpp     | 63 ++++++++++++++++---
 2 files changed, 95 insertions(+), 16 deletions(-)

diff --git a/llvm/test/TableGen/AsmMatcherCoerceFromRegClass.td b/llvm/test/TableGen/AsmMatcherCoerceFromRegClass.td
index 3366fcedd4b5bc..e69bb80f3650ac 100644
--- a/llvm/test/TableGen/AsmMatcherCoerceFromRegClass.td
+++ b/llvm/test/TableGen/AsmMatcherCoerceFromRegClass.td
@@ -22,8 +22,13 @@ let Namespace = "Arch" in {
   def V1 : Register<"v1">;
   def V2 : Register<"v2">;
   def V3 : Register<"v3">;
+  def V4 : Register<"v4">;
+  def V5 : Register<"v5">;
   def V0M2 : Register<"v0">;
   def V2M2 : Register<"v2">;
+  def V4M2 : Register<"v4">;
+  def V0M4 : Register<"v0">;
+  def V4M4 : Register<"v4">;
 }
 
 def GPR : RegisterClass<"Arch", [i32], 32, (add R0, R1)>;
@@ -36,9 +41,14 @@ def YGPR : RegisterClass<"Arch", [i64], 64, (add R0_Y, R1_Y)> {
   let CoerceFromRegClass = GPR;
 }
 
-/// Only the even registers in VR have a counterpart in VRM2.
-def VR : RegisterClass<"Arch", [v2i32], 64, (add V0, V1, V2, V3)>;
-def VRM2 : RegisterClass<"Arch", [v4i32], 128, (add V0M2, V2M2)> {
+/// Only the even/4-aligned registers in VR have counterparts in VRM2/VRM4.
+/// V0M4 interleaves between V0M2 and V2M2 in enum order, so VRM2 falls back to
+/// a switch while VRM4 uses strided arithmetic.
+def VR : RegisterClass<"Arch", [v2i32], 64, (add V0, V1, V2, V3, V4, V5)>;
+def VRM2 : RegisterClass<"Arch", [v4i32], 128, (add V0M2, V2M2, V4M2)> {
+  let CoerceFromRegClass = VR;
+}
+def VRM4 : RegisterClass<"Arch", [v8i32], 256, (add V0M4, V4M4)> {
   let CoerceFromRegClass = VR;
 }
 
@@ -67,6 +77,12 @@ def InstVRM2 : Instruction {
   let AsmString = "vinst $vd, $vs";
 }
 
+def InstVRM4 : Instruction {
+  let OutOperandList = (outs VRM4:$vd);
+  let InOperandList = (ins VR:$vs);
+  let AsmString = "v4inst $vd, $vs";
+}
+
 def InstPtr : Instruction {
   let OutOperandList = (outs GPR:$rd);
   let InOperandList = (ins PtrRC:$ptr);
@@ -81,26 +97,37 @@ def BadRC : RegisterClass<"Arch", [i64], 64, (add R0_Y, R0)> {
 // ERR-DUPLICATE-NAME: error: RegisterClass 'BadRC' with CoerceFromRegClass contains multiple registers named 'r0'
 #endif
 
+// CHECK-LABEL: static MCRegister convertToVRM4(MCRegister Reg) {
+// CHECK-NEXT:    assert(Reg.id() >= Arch::V0 && Reg.id() <= Arch::V4 &&
+// CHECK-NEXT:           (Reg.id() - Arch::V0) % 4 == 0 && "unexpected register");
+// CHECK-NEXT:    return Arch::V0M4 + (Reg.id() - Arch::V0) / 4 * 3;
+// CHECK-NEXT:  }
+
 // CHECK-LABEL: static MCRegister convertToVRM2(MCRegister Reg) {
 // CHECK-NEXT:    switch (Reg.id()) {
 // CHECK-NEXT:    case Arch::V0: return Arch::V0M2;
 // CHECK-NEXT:    case Arch::V2: return Arch::V2M2;
+// CHECK-NEXT:    case Arch::V4: return Arch::V4M2;
 // CHECK-NEXT:    default: llvm_unreachable("unexpected register");
 // CHECK-NEXT:    }
 // CHECK-NEXT:  }
 
 // CHECK-LABEL: static MCRegister convertToYGPR(MCRegister Reg) {
-// CHECK-NEXT:    switch (Reg.id()) {
-// CHECK-NEXT:    case Arch::R0: return Arch::R0_Y;
-// CHECK-NEXT:    case Arch::R1: return Arch::R1_Y;
-// CHECK-NEXT:    default: llvm_unreachable("unexpected register");
-// CHECK-NEXT:    }
+// CHECK-NEXT:    assert(Reg.id() >= Arch::R0 && Reg.id() <= Arch::R1 && "unexpected register");
+// CHECK-NEXT:    return Arch::R0_Y + (Reg.id() - Arch::R0);
 // CHECK-NEXT:  }
 
 // CHECK-LABEL: convertToMCInst(
 // CHECK:       case CVT_95_Reg:
 // CHECK-NEXT:    static_cast<ArchOperand &>(*Operands[OpIdx]).addRegOperands(Inst, 1);
 // CHECK-NEXT:    break;
+// CHECK-NEXT:  case CVT_95_convertToVRM4: {
+// CHECK-NEXT:    MCRegister Reg = Operands[OpIdx]->getReg();
+// CHECK-NEXT:    if (!getArchMCRegisterClass(Arch::VRM4RegClassID).contains(Reg))
+// CHECK-NEXT:      Reg = convertToVRM4(Reg);
+// CHECK-NEXT:    Inst.addOperand(MCOperand::createReg(Reg));
+// CHECK-NEXT:    break;
+// CHECK-NEXT:  }
 // CHECK-NEXT:  case CVT_95_convertToVRM2: {
 // CHECK-NEXT:    MCRegister Reg = Operands[OpIdx]->getReg();
 // CHECK-NEXT:    if (!getArchMCRegisterClass(Arch::VRM2RegClassID).contains(Reg))
@@ -131,14 +158,17 @@ def BadRC : RegisterClass<"Arch", [i64], 64, (add R0_Y, R0)> {
 // 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}).
+/// registers, whereas VRM2 and VRM4 get their own match classes.
 // CHECK-LABEL: enum MatchClassKind {
 // CHECK:         MCK_GPR, // register class 'GPR'
+// CHECK-NEXT:    MCK_Reg3, // derived register class
 // CHECK-NEXT:    MCK_AnyGPR, // register class 'AnyGPR,YGPR'
+// CHECK-NEXT:    MCK_VRM4, // register class 'VRM4'
 // CHECK-NEXT:    MCK_VR, // register class 'VR'
 // CHECK-NEXT:    MCK_VRM2, // register class 'VRM2'
 
 // CHECK-LABEL: MatchEntry MatchTable0[] = {
 // CHECK-NEXT:    /* anyinst */, Arch::InstAnyGPR, Convert__Reg1_0__Reg1_1, AMFBS_None, { MCK_AnyGPR, MCK_GPR },
+// CHECK-NEXT:    /* v4inst */, Arch::InstVRM4, Convert__VRM41_0__Reg1_1, AMFBS_None, { MCK_VRM4, MCK_VR },
 // CHECK-NEXT:    /* vinst */, Arch::InstVRM2, Convert__VRM21_0__Reg1_1, AMFBS_None, { MCK_VRM2, MCK_VR },
 // CHECK-NEXT:    /* yinst */, Arch::InstYGPR, Convert__YGPR1_0__Reg1_1, AMFBS_None, { MCK_AnyGPR, MCK_GPR },
diff --git a/llvm/utils/TableGen/AsmMatcherEmitter.cpp b/llvm/utils/TableGen/AsmMatcherEmitter.cpp
index 38b270f0d5b35a..194f427aa69a2b 100644
--- a/llvm/utils/TableGen/AsmMatcherEmitter.cpp
+++ b/llvm/utils/TableGen/AsmMatcherEmitter.cpp
@@ -1349,11 +1349,20 @@ void AsmMatcherInfo::buildRegisterClasses(
     }
     const CodeGenRegisterClass *FromRC = Target.getRegBank().getRegClass(
         Def->getValueAsDef("CoerceFromRegClass"));
+    SmallVector<RegConversion, 0> Conversions;
     for (const Record *From : FromRC->getOrder()) {
       const Record *To =
           RegsByAsmName.lookup(From->getValueAsString("AsmName"));
       if (To && To != From)
-        RegConversions[Def].push_back({From, To});
+        Conversions.push_back({From, To});
+    }
+    if (!Conversions.empty()) {
+      llvm::sort(Conversions,
+                 [&](const RegConversion &LHS, const RegConversion &RHS) {
+                   return Target.getRegBank().getReg(LHS.From)->EnumValue <
+                          Target.getRegBank().getReg(RHS.From)->EnumValue;
+                 });
+      RegConversions.try_emplace(Def, std::move(Conversions));
     }
   }
 
@@ -2555,18 +2564,58 @@ static unsigned emitConvertFuncs(CodeGenTarget &Target, StringRef ClassName,
   OS << "};\n\n";
 
   // Spit out the functions converting registers matched via CoerceFromRegClass.
-  for (const Record *RC : CoercedRegClasses) {
+  CodeGenRegBank &RegBank = Target.getRegBank();
+  auto emitRegCoercionFunc = [&](const Record *RC) {
+    ArrayRef<AsmMatcherInfo::RegConversion> Conversions =
+        Info.RegConversions.find(RC)->second;
     OS << "static MCRegister convertTo" << RC->getName()
-       << "(MCRegister Reg) {\n"
-       << "  switch (Reg.id()) {\n";
-    for (const AsmMatcherInfo::RegConversion &C :
-         Info.RegConversions.lookup(RC))
+       << "(MCRegister Reg) {\n";
+    auto getEnum = [&](const Record *R) -> int64_t {
+      return RegBank.getReg(R)->EnumValue;
+    };
+    if (Conversions.size() >= 2) {
+      int64_t FirstFrom = getEnum(Conversions[0].From);
+      int64_t FirstTo = getEnum(Conversions[0].To);
+      int64_t FromStride = getEnum(Conversions[1].From) - FirstFrom;
+      int64_t ToStride = getEnum(Conversions[1].To) - FirstTo;
+      bool IsLinear =
+          ToStride > 0 && all_of(enumerate(Conversions), [&](const auto &Item) {
+            int64_t Idx = Item.index();
+            return getEnum(Item.value().From) == FirstFrom + Idx * FromStride &&
+                   getEnum(Item.value().To) == FirstTo + Idx * ToStride;
+          });
+      if (IsLinear) {
+        std::string FirstFromName = getQualifiedName(Conversions.front().From);
+        std::string LastFromName = getQualifiedName(Conversions.back().From);
+        std::string FirstToName = getQualifiedName(Conversions.front().To);
+        OS << "  assert(Reg.id() >= " << FirstFromName
+           << " && Reg.id() <= " << LastFromName;
+        if (FromStride > 1)
+          OS << " &&\n         (Reg.id() - " << FirstFromName << ") % "
+             << FromStride << " == 0";
+        OS << " && \"unexpected register\");\n"
+           << "  return " << FirstToName << " + (Reg.id() - " << FirstFromName
+           << ")";
+        if (FromStride != ToStride) {
+          if (FromStride > 1)
+            OS << " / " << FromStride;
+          if (ToStride > 1)
+            OS << " * " << ToStride;
+        }
+        OS << ";\n}\n\n";
+        return;
+      }
+    }
+    OS << "  switch (Reg.id()) {\n";
+    for (const AsmMatcherInfo::RegConversion &C : Conversions)
       OS << "  case " << getQualifiedName(C.From) << ": return "
          << getQualifiedName(C.To) << ";\n";
     OS << "  default: llvm_unreachable(\"unexpected register\");\n"
        << "  }\n"
        << "}\n\n";
-  }
+  };
+  for (const Record *RC : CoercedRegClasses)
+    emitRegCoercionFunc(RC);
 
   // Spit out the conversion driver function.
   OS << ConvertFnBody;

>From e868e70118aca6a49657f0556a6b041474ed5427 Mon Sep 17 00:00:00 2001
From: Alex Richardson <alexrichardson at google.com>
Date: Thu, 12 Nov 2026 15:17:32 -0800
Subject: [PATCH 2/4] [nspr] update

---
 llvm/utils/TableGen/AsmMatcherEmitter.cpp | 112 ++++++++++------------
 1 file changed, 52 insertions(+), 60 deletions(-)

diff --git a/llvm/utils/TableGen/AsmMatcherEmitter.cpp b/llvm/utils/TableGen/AsmMatcherEmitter.cpp
index 194f427aa69a2b..54cdccb1e37340 100644
--- a/llvm/utils/TableGen/AsmMatcherEmitter.cpp
+++ b/llvm/utils/TableGen/AsmMatcherEmitter.cpp
@@ -120,6 +120,7 @@
 #include <cctype>
 #include <forward_list>
 #include <map>
+#include <numeric>
 #include <set>
 
 using namespace llvm;
@@ -1349,20 +1350,12 @@ void AsmMatcherInfo::buildRegisterClasses(
     }
     const CodeGenRegisterClass *FromRC = Target.getRegBank().getRegClass(
         Def->getValueAsDef("CoerceFromRegClass"));
-    SmallVector<RegConversion, 0> Conversions;
-    for (const Record *From : FromRC->getOrder()) {
+    // Iterate getMembers() so conversions are ordered by EnumValue.
+    for (const CodeGenRegister *From : FromRC->getMembers()) {
       const Record *To =
-          RegsByAsmName.lookup(From->getValueAsString("AsmName"));
-      if (To && To != From)
-        Conversions.push_back({From, To});
-    }
-    if (!Conversions.empty()) {
-      llvm::sort(Conversions,
-                 [&](const RegConversion &LHS, const RegConversion &RHS) {
-                   return Target.getRegBank().getReg(LHS.From)->EnumValue <
-                          Target.getRegBank().getReg(RHS.From)->EnumValue;
-                 });
-      RegConversions.try_emplace(Def, std::move(Conversions));
+          RegsByAsmName.lookup(From->TheDef->getValueAsString("AsmName"));
+      if (To && To != From->TheDef)
+        RegConversions[Def].push_back({From->TheDef, To});
     }
   }
 
@@ -2101,6 +2094,42 @@ getConverterOperandID(const std::string &Name,
   return ID;
 }
 
+static bool
+tryEmitLinearRegCoercion(CodeGenRegBank &RegBank, raw_ostream &OS,
+                         ArrayRef<AsmMatcherInfo::RegConversion> Conversions) {
+  if (Conversions.size() < 2)
+    return false;
+  auto getEnum = [&](const Record *R) { return RegBank.getReg(R)->EnumValue; };
+  unsigned FirstFrom = getEnum(Conversions[0].From);
+  unsigned FirstTo = getEnum(Conversions[0].To);
+  if (getEnum(Conversions[1].To) <= FirstTo)
+    return false;
+  unsigned FromStride = getEnum(Conversions[1].From) - FirstFrom;
+  unsigned ToStride = getEnum(Conversions[1].To) - FirstTo;
+  for (auto [Idx, C] : enumerate(Conversions))
+    if (getEnum(C.From) != FirstFrom + Idx * FromStride ||
+        getEnum(C.To) != FirstTo + Idx * ToStride)
+      return false;
+
+  std::string FirstFromName = getQualifiedName(Conversions.front().From);
+  std::string LastFromName = getQualifiedName(Conversions.back().From);
+  std::string FirstToName = getQualifiedName(Conversions.front().To);
+  OS << formatv("  assert(Reg.id() >= {0} && Reg.id() <= {1}", FirstFromName,
+                LastFromName);
+  if (FromStride > 1)
+    OS << formatv(" &&\n         (Reg.id() - {0}) % {1} == 0", FirstFromName,
+                  FromStride);
+  OS << " && \"unexpected register\");\n"
+     << formatv("  return {0} + (Reg.id() - {1})", FirstToName, FirstFromName);
+  unsigned G = std::gcd(FromStride, ToStride);
+  if (FromStride / G > 1)
+    OS << " / " << (FromStride / G);
+  if (ToStride / G > 1)
+    OS << " * " << (ToStride / G);
+  OS << ";\n";
+  return true;
+}
+
 static unsigned emitConvertFuncs(CodeGenTarget &Target, StringRef ClassName,
                                  AsmMatcherInfo &Info, bool HasMnemonicFirst,
                                  bool HasOptionalOperands, raw_ostream &OS) {
@@ -2564,58 +2593,21 @@ static unsigned emitConvertFuncs(CodeGenTarget &Target, StringRef ClassName,
   OS << "};\n\n";
 
   // Spit out the functions converting registers matched via CoerceFromRegClass.
-  CodeGenRegBank &RegBank = Target.getRegBank();
-  auto emitRegCoercionFunc = [&](const Record *RC) {
+  for (const Record *RC : CoercedRegClasses) {
     ArrayRef<AsmMatcherInfo::RegConversion> Conversions =
         Info.RegConversions.find(RC)->second;
     OS << "static MCRegister convertTo" << RC->getName()
        << "(MCRegister Reg) {\n";
-    auto getEnum = [&](const Record *R) -> int64_t {
-      return RegBank.getReg(R)->EnumValue;
-    };
-    if (Conversions.size() >= 2) {
-      int64_t FirstFrom = getEnum(Conversions[0].From);
-      int64_t FirstTo = getEnum(Conversions[0].To);
-      int64_t FromStride = getEnum(Conversions[1].From) - FirstFrom;
-      int64_t ToStride = getEnum(Conversions[1].To) - FirstTo;
-      bool IsLinear =
-          ToStride > 0 && all_of(enumerate(Conversions), [&](const auto &Item) {
-            int64_t Idx = Item.index();
-            return getEnum(Item.value().From) == FirstFrom + Idx * FromStride &&
-                   getEnum(Item.value().To) == FirstTo + Idx * ToStride;
-          });
-      if (IsLinear) {
-        std::string FirstFromName = getQualifiedName(Conversions.front().From);
-        std::string LastFromName = getQualifiedName(Conversions.back().From);
-        std::string FirstToName = getQualifiedName(Conversions.front().To);
-        OS << "  assert(Reg.id() >= " << FirstFromName
-           << " && Reg.id() <= " << LastFromName;
-        if (FromStride > 1)
-          OS << " &&\n         (Reg.id() - " << FirstFromName << ") % "
-             << FromStride << " == 0";
-        OS << " && \"unexpected register\");\n"
-           << "  return " << FirstToName << " + (Reg.id() - " << FirstFromName
-           << ")";
-        if (FromStride != ToStride) {
-          if (FromStride > 1)
-            OS << " / " << FromStride;
-          if (ToStride > 1)
-            OS << " * " << ToStride;
-        }
-        OS << ";\n}\n\n";
-        return;
-      }
+    if (!tryEmitLinearRegCoercion(Target.getRegBank(), OS, Conversions)) {
+      OS << "  switch (Reg.id()) {\n";
+      for (const AsmMatcherInfo::RegConversion &C : Conversions)
+        OS << "  case " << getQualifiedName(C.From) << ": return "
+           << getQualifiedName(C.To) << ";\n";
+      OS << "  default: llvm_unreachable(\"unexpected register\");\n"
+         << "  }\n";
     }
-    OS << "  switch (Reg.id()) {\n";
-    for (const AsmMatcherInfo::RegConversion &C : Conversions)
-      OS << "  case " << getQualifiedName(C.From) << ": return "
-         << getQualifiedName(C.To) << ";\n";
-    OS << "  default: llvm_unreachable(\"unexpected register\");\n"
-       << "  }\n"
-       << "}\n\n";
-  };
-  for (const Record *RC : CoercedRegClasses)
-    emitRegCoercionFunc(RC);
+    OS << "}\n\n";
+  }
 
   // Spit out the conversion driver function.
   OS << ConvertFnBody;

>From 65ae3c34d27f54144fa5dd3c92610b893c8d72d8 Mon Sep 17 00:00:00 2001
From: Alex Richardson <alexrichardson at google.com>
Date: Thu, 12 Nov 2026 17:13:27 -0800
Subject: [PATCH 3/4] [nspr] update

---
 llvm/test/TableGen/AsmMatcherCoerceFromRegClass.td | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/llvm/test/TableGen/AsmMatcherCoerceFromRegClass.td b/llvm/test/TableGen/AsmMatcherCoerceFromRegClass.td
index e69bb80f3650ac..2d5e30eece2f59 100644
--- a/llvm/test/TableGen/AsmMatcherCoerceFromRegClass.td
+++ b/llvm/test/TableGen/AsmMatcherCoerceFromRegClass.td
@@ -24,9 +24,12 @@ let Namespace = "Arch" in {
   def V3 : Register<"v3">;
   def V4 : Register<"v4">;
   def V5 : Register<"v5">;
+  def V6 : Register<"v6">;
+  def V7 : Register<"v7">;
   def V0M2 : Register<"v0">;
   def V2M2 : Register<"v2">;
   def V4M2 : Register<"v4">;
+  def V6M2 : Register<"v6">;
   def V0M4 : Register<"v0">;
   def V4M4 : Register<"v4">;
 }
@@ -44,8 +47,9 @@ def YGPR : RegisterClass<"Arch", [i64], 64, (add R0_Y, R1_Y)> {
 /// Only the even/4-aligned registers in VR have counterparts in VRM2/VRM4.
 /// V0M4 interleaves between V0M2 and V2M2 in enum order, so VRM2 falls back to
 /// a switch while VRM4 uses strided arithmetic.
-def VR : RegisterClass<"Arch", [v2i32], 64, (add V0, V1, V2, V3, V4, V5)>;
-def VRM2 : RegisterClass<"Arch", [v4i32], 128, (add V0M2, V2M2, V4M2)> {
+def VR : RegisterClass<"Arch", [v2i32], 64,
+                       (add V0, V1, V2, V3, V4, V5, V6, V7)>;
+def VRM2 : RegisterClass<"Arch", [v4i32], 128, (add V0M2, V2M2, V4M2, V6M2)> {
   let CoerceFromRegClass = VR;
 }
 def VRM4 : RegisterClass<"Arch", [v8i32], 256, (add V0M4, V4M4)> {
@@ -108,6 +112,7 @@ def BadRC : RegisterClass<"Arch", [i64], 64, (add R0_Y, R0)> {
 // CHECK-NEXT:    case Arch::V0: return Arch::V0M2;
 // CHECK-NEXT:    case Arch::V2: return Arch::V2M2;
 // CHECK-NEXT:    case Arch::V4: return Arch::V4M2;
+// CHECK-NEXT:    case Arch::V6: return Arch::V6M2;
 // CHECK-NEXT:    default: llvm_unreachable("unexpected register");
 // CHECK-NEXT:    }
 // CHECK-NEXT:  }

>From 8ba539ab251866d3f8d618672d5b1c1b31d69294 Mon Sep 17 00:00:00 2001
From: Alex Richardson <alexrichardson at google.com>
Date: Tue, 17 Nov 2026 14:53:10 -0800
Subject: [PATCH 4/4] [nspr] update

---
 llvm/utils/TableGen/AsmMatcherEmitter.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/llvm/utils/TableGen/AsmMatcherEmitter.cpp b/llvm/utils/TableGen/AsmMatcherEmitter.cpp
index 54cdccb1e37340..7f0c52d36661cd 100644
--- a/llvm/utils/TableGen/AsmMatcherEmitter.cpp
+++ b/llvm/utils/TableGen/AsmMatcherEmitter.cpp
@@ -2102,6 +2102,8 @@ tryEmitLinearRegCoercion(CodeGenRegBank &RegBank, raw_ostream &OS,
   auto getEnum = [&](const Record *R) { return RegBank.getReg(R)->EnumValue; };
   unsigned FirstFrom = getEnum(Conversions[0].From);
   unsigned FirstTo = getEnum(Conversions[0].To);
+  assert(getEnum(Conversions[1].From) > FirstFrom &&
+         "getMembers() is sorted by EnumValue");
   if (getEnum(Conversions[1].To) <= FirstTo)
     return false;
   unsigned FromStride = getEnum(Conversions[1].From) - FirstFrom;



More information about the llvm-branch-commits mailing list