[llvm-branch-commits] [llvm] [RISCV] Make the RISCVABI enum an enum class. NFC (PR #239007)

via llvm-branch-commits llvm-branch-commits at lists.llvm.org
Wed Nov 4 15:03:09 PST 2026


llvmorg-github-actions[bot] wrote:


<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-backend-risc-v

Author: Craig Topper (topperc)

<details>
<summary>Changes</summary>

Assisted-by: Claude

---
Full diff: https://github.com/llvm/llvm-project/pull/239007.diff


10 Files Affected:

- (modified) llvm/lib/Target/RISCV/MCTargetDesc/RISCVBaseInfo.cpp (+26-26) 
- (modified) llvm/lib/Target/RISCV/MCTargetDesc/RISCVBaseInfo.h (+48-48) 
- (modified) llvm/lib/Target/RISCV/MCTargetDesc/RISCVTargetStreamer.cpp (+1-1) 
- (modified) llvm/lib/Target/RISCV/MCTargetDesc/RISCVTargetStreamer.h (+2-2) 
- (modified) llvm/lib/Target/RISCV/RISCVAsmPrinter.cpp (+1-1) 
- (modified) llvm/lib/Target/RISCV/RISCVCallingConv.cpp (+2-2) 
- (modified) llvm/lib/Target/RISCV/RISCVISelLowering.cpp (+1-1) 
- (modified) llvm/lib/Target/RISCV/RISCVRegisterInfo.cpp (+2-2) 
- (modified) llvm/lib/Target/RISCV/RISCVSubtarget.h (+1-1) 
- (modified) llvm/unittests/Target/RISCV/RISCVBaseInfoTest.cpp (+15-15) 


``````````diff
diff --git a/llvm/lib/Target/RISCV/MCTargetDesc/RISCVBaseInfo.cpp b/llvm/lib/Target/RISCV/MCTargetDesc/RISCVBaseInfo.cpp
index c4355505dd023c..be54dbd662636d 100644
--- a/llvm/lib/Target/RISCV/MCTargetDesc/RISCVBaseInfo.cpp
+++ b/llvm/lib/Target/RISCV/MCTargetDesc/RISCVBaseInfo.cpp
@@ -59,7 +59,7 @@ Expected<ABI> computeTargetABI(const MCSubtargetInfo &STI, StringRef ABIName) {
   bool IsRVE = FeatureBits[RISCV::FeatureStdExtE];
   bool IsXCheriot = FeatureBits[RISCV::FeatureVendorXCheriot];
 
-  if (!ABIName.empty() && TargetABI == ABI_Unknown) {
+  if (!ABIName.empty() && TargetABI == ABI::Unknown) {
     return createStringError(Twine("'") + ABIName +
                              "' is not a recognized ABI for this target");
   }
@@ -88,25 +88,25 @@ Expected<ABI> computeTargetABI(const MCSubtargetInfo &STI, StringRef ABIName) {
     return createStringError(Twine('\'') + ABIName +
                              "' ABI is only supported for RVY targets");
   }
-  if (!IsRV64 && IsRVE && !IsXCheriot && TargetABI != ABI_ILP32E &&
-      TargetABI != ABI_Unknown) {
+  if (!IsRV64 && IsRVE && !IsXCheriot && TargetABI != ABI::ILP32E &&
+      TargetABI != ABI::Unknown) {
     return createStringError("only the ilp32e ABI is supported for RV32E");
   }
-  if (!IsRV64 && IsRVE && IsXCheriot && TargetABI != ABI_CHERIOT &&
-      TargetABI != ABI_Unknown) {
+  if (!IsRV64 && IsRVE && IsXCheriot && TargetABI != ABI::CHERIOT &&
+      TargetABI != ABI::Unknown) {
     return createStringError("only the cheriot ABI is supported for XCheriot");
   }
-  if (IsRV64 && IsRVE && TargetABI != ABI_LP64E && TargetABI != ABI_Unknown) {
+  if (IsRV64 && IsRVE && TargetABI != ABI::LP64E && TargetABI != ABI::Unknown) {
     return createStringError("only the lp64e ABI is supported for RV64E");
   }
 
   // Unconditionally fatal: no sensible default ABI to fall back to here.
-  if ((TargetABI == ABI_ILP32E ||
-       (TargetABI == ABI_Unknown && IsRVE && !IsRV64)) &&
+  if ((TargetABI == ABI::ILP32E ||
+       (TargetABI == ABI::Unknown && IsRVE && !IsRV64)) &&
       FeatureBits[RISCV::FeatureStdExtD])
     reportFatalUsageError("ILP32E cannot be used with the D ISA extension");
 
-  if (TargetABI != ABI_Unknown)
+  if (TargetABI != ABI::Unknown)
     return TargetABI;
 
   // If no explicit ABI is given, try to compute the default ABI.
@@ -118,23 +118,23 @@ Expected<ABI> computeTargetABI(const MCSubtargetInfo &STI, StringRef ABIName) {
 
 ABI getTargetABI(StringRef ABIName) {
   auto TargetABI = StringSwitch<ABI>(ABIName)
-                       .Case("ilp32", ABI_ILP32)
-                       .Case("ilp32f", ABI_ILP32F)
-                       .Case("ilp32d", ABI_ILP32D)
-                       .Case("ilp32e", ABI_ILP32E)
-                       .Case("il32pc64", ABI_IL32PC64)
-                       .Case("il32pc64f", ABI_IL32PC64F)
-                       .Case("il32pc64d", ABI_IL32PC64D)
-                       .Case("il32pc64e", ABI_IL32PC64E)
-                       .Case("lp64", ABI_LP64)
-                       .Case("lp64f", ABI_LP64F)
-                       .Case("lp64d", ABI_LP64D)
-                       .Case("lp64e", ABI_LP64E)
-                       .Case("l64pc128", ABI_L64PC128)
-                       .Case("l64pc128f", ABI_L64PC128F)
-                       .Case("l64pc128d", ABI_L64PC128D)
-                       .Case("cheriot", ABI_CHERIOT)
-                       .Default(ABI_Unknown);
+                       .Case("ilp32", ABI::ILP32)
+                       .Case("ilp32f", ABI::ILP32F)
+                       .Case("ilp32d", ABI::ILP32D)
+                       .Case("ilp32e", ABI::ILP32E)
+                       .Case("il32pc64", ABI::IL32PC64)
+                       .Case("il32pc64f", ABI::IL32PC64F)
+                       .Case("il32pc64d", ABI::IL32PC64D)
+                       .Case("il32pc64e", ABI::IL32PC64E)
+                       .Case("lp64", ABI::LP64)
+                       .Case("lp64f", ABI::LP64F)
+                       .Case("lp64d", ABI::LP64D)
+                       .Case("lp64e", ABI::LP64E)
+                       .Case("l64pc128", ABI::L64PC128)
+                       .Case("l64pc128f", ABI::L64PC128F)
+                       .Case("l64pc128d", ABI::L64PC128D)
+                       .Case("cheriot", ABI::CHERIOT)
+                       .Default(ABI::Unknown);
   return TargetABI;
 }
 
diff --git a/llvm/lib/Target/RISCV/MCTargetDesc/RISCVBaseInfo.h b/llvm/lib/Target/RISCV/MCTargetDesc/RISCVBaseInfo.h
index 3347cb3fd24148..9ab55df9cab6d5 100644
--- a/llvm/lib/Target/RISCV/MCTargetDesc/RISCVBaseInfo.h
+++ b/llvm/lib/Target/RISCV/MCTargetDesc/RISCVBaseInfo.h
@@ -714,38 +714,38 @@ struct RISCVOpcode {
 
 namespace RISCVABI {
 
-enum ABI {
-  ABI_ILP32,
-  ABI_ILP32F,
-  ABI_ILP32D,
-  ABI_ILP32E,
-  ABI_IL32PC64,
-  ABI_IL32PC64F,
-  ABI_IL32PC64D,
-  ABI_IL32PC64E,
-  ABI_LP64,
-  ABI_LP64F,
-  ABI_LP64D,
-  ABI_LP64E,
-  ABI_L64PC128,
-  ABI_L64PC128F,
-  ABI_L64PC128D,
-  ABI_CHERIOT,
-  ABI_Unknown
+enum class ABI {
+  ILP32,
+  ILP32F,
+  ILP32D,
+  ILP32E,
+  IL32PC64,
+  IL32PC64F,
+  IL32PC64D,
+  IL32PC64E,
+  LP64,
+  LP64F,
+  LP64D,
+  LP64E,
+  L64PC128,
+  L64PC128F,
+  L64PC128D,
+  CHERIOT,
+  Unknown
 };
 
 // Returns true for the ABIs that pass all floating point values in integer
 // registers.
 inline bool isSoftFP(ABI TargetABI) {
   switch (TargetABI) {
-  case ABI_ILP32:
-  case ABI_ILP32E:
-  case ABI_IL32PC64:
-  case ABI_IL32PC64E:
-  case ABI_LP64:
-  case ABI_LP64E:
-  case ABI_L64PC128:
-  case ABI_CHERIOT:
+  case ABI::ILP32:
+  case ABI::ILP32E:
+  case ABI::IL32PC64:
+  case ABI::IL32PC64E:
+  case ABI::LP64:
+  case ABI::LP64E:
+  case ABI::L64PC128:
+  case ABI::CHERIOT:
     return true;
   default:
     return false;
@@ -757,10 +757,10 @@ inline bool isSoftFP(ABI TargetABI) {
 // are passed in integer registers.
 inline bool isSingleFP(ABI TargetABI) {
   switch (TargetABI) {
-  case ABI_ILP32F:
-  case ABI_IL32PC64F:
-  case ABI_LP64F:
-  case ABI_L64PC128F:
+  case ABI::ILP32F:
+  case ABI::IL32PC64F:
+  case ABI::LP64F:
+  case ABI::L64PC128F:
     return true;
   default:
     return false;
@@ -772,10 +772,10 @@ inline bool isSingleFP(ABI TargetABI) {
 // in integer registers.
 inline bool isDoubleFP(ABI TargetABI) {
   switch (TargetABI) {
-  case ABI_ILP32D:
-  case ABI_IL32PC64D:
-  case ABI_LP64D:
-  case ABI_L64PC128D:
+  case ABI::ILP32D:
+  case ABI::IL32PC64D:
+  case ABI::LP64D:
+  case ABI::L64PC128D:
     return true;
   default:
     return false;
@@ -785,10 +785,10 @@ inline bool isDoubleFP(ABI TargetABI) {
 // Returns true for the ABIs that only use the reduced 16 register integer file.
 inline bool isRVE(ABI TargetABI) {
   switch (TargetABI) {
-  case ABI_ILP32E:
-  case ABI_IL32PC64E:
-  case ABI_LP64E:
-  case ABI_CHERIOT:
+  case ABI::ILP32E:
+  case ABI::IL32PC64E:
+  case ABI::LP64E:
+  case ABI::CHERIOT:
     return true;
   default:
     return false;
@@ -798,14 +798,14 @@ inline bool isRVE(ABI TargetABI) {
 // Returns true for the ABIs in which pointers are capabilities.
 inline bool isPurecap(ABI TargetABI) {
   switch (TargetABI) {
-  case ABI_IL32PC64:
-  case ABI_IL32PC64F:
-  case ABI_IL32PC64D:
-  case ABI_IL32PC64E:
-  case ABI_L64PC128:
-  case ABI_L64PC128F:
-  case ABI_L64PC128D:
-  case ABI_CHERIOT:
+  case ABI::IL32PC64:
+  case ABI::IL32PC64F:
+  case ABI::IL32PC64D:
+  case ABI::IL32PC64E:
+  case ABI::L64PC128:
+  case ABI::L64PC128F:
+  case ABI::L64PC128D:
+  case ABI::CHERIOT:
     return true;
   default:
     return false;
@@ -815,9 +815,9 @@ inline bool isPurecap(ABI TargetABI) {
 // Returns the stack alignment required by the ABI.
 // FIXME: Add the purecap variants of the E ABIs?
 inline Align getStackAlignment(ABI TargetABI) {
-  if (TargetABI == ABI_ILP32E)
+  if (TargetABI == ABI::ILP32E)
     return Align(4);
-  if (TargetABI == ABI_LP64E)
+  if (TargetABI == ABI::LP64E)
     return Align(8);
   return Align(16);
 }
diff --git a/llvm/lib/Target/RISCV/MCTargetDesc/RISCVTargetStreamer.cpp b/llvm/lib/Target/RISCV/MCTargetDesc/RISCVTargetStreamer.cpp
index 86fb2d1a0d080d..a43b6e50b6179b 100644
--- a/llvm/lib/Target/RISCV/MCTargetDesc/RISCVTargetStreamer.cpp
+++ b/llvm/lib/Target/RISCV/MCTargetDesc/RISCVTargetStreamer.cpp
@@ -53,7 +53,7 @@ void RISCVTargetStreamer::emitIntTextAttribute(unsigned Attribute,
                                                StringRef StringValue) {}
 
 void RISCVTargetStreamer::setTargetABI(RISCVABI::ABI ABI) {
-  assert(ABI != RISCVABI::ABI_Unknown && "Improperly initialized target ABI");
+  assert(ABI != RISCVABI::ABI::Unknown && "Improperly initialized target ABI");
   TargetABI = ABI;
 }
 
diff --git a/llvm/lib/Target/RISCV/MCTargetDesc/RISCVTargetStreamer.h b/llvm/lib/Target/RISCV/MCTargetDesc/RISCVTargetStreamer.h
index 6de135d60c73d9..a81b5774a168ce 100644
--- a/llvm/lib/Target/RISCV/MCTargetDesc/RISCVTargetStreamer.h
+++ b/llvm/lib/Target/RISCV/MCTargetDesc/RISCVTargetStreamer.h
@@ -34,7 +34,7 @@ struct RISCVOptionArchArg {
 
 class RISCVTargetStreamer : public MCTargetStreamer {
   const RISCVMCOptions &CLOpts;
-  RISCVABI::ABI TargetABI = RISCVABI::ABI_Unknown;
+  RISCVABI::ABI TargetABI = RISCVABI::ABI::Unknown;
   bool HasRVC = false;
   bool HasTSO = false;
 
@@ -65,7 +65,7 @@ class RISCVTargetStreamer : public MCTargetStreamer {
   void emitTargetAttributes(const MCSubtargetInfo &STI, bool EmitStackAlign);
   void setTargetABI(RISCVABI::ABI ABI);
   RISCVABI::ABI getTargetABI() const { return TargetABI; }
-  bool hasTargetABI() const { return TargetABI != RISCVABI::ABI_Unknown; }
+  bool hasTargetABI() const { return TargetABI != RISCVABI::ABI::Unknown; }
   virtual void setFlagsFromFeatures(const MCSubtargetInfo &STI);
   bool hasRVC() const { return HasRVC; }
   bool hasTSO() const { return HasTSO; }
diff --git a/llvm/lib/Target/RISCV/RISCVAsmPrinter.cpp b/llvm/lib/Target/RISCV/RISCVAsmPrinter.cpp
index 4525d2c944563e..29afd3934b0bb2 100644
--- a/llvm/lib/Target/RISCV/RISCVAsmPrinter.cpp
+++ b/llvm/lib/Target/RISCV/RISCVAsmPrinter.cpp
@@ -655,7 +655,7 @@ void RISCVAsmPrinter::emitStartOfAsmFile(Module &M) {
   StringRef ABIName = M.getTargetABIFromMD();
   if (!ABIName.empty()) {
     RISCVABI::ABI ABI = RISCVABI::getTargetABI(ABIName);
-    if (ABI == RISCVABI::ABI_Unknown) {
+    if (ABI == RISCVABI::ABI::Unknown) {
       M.getContext().emitError(Twine('\'') + ABIName +
                                "' is not a recognized ABI for this target");
     } else {
diff --git a/llvm/lib/Target/RISCV/RISCVCallingConv.cpp b/llvm/lib/Target/RISCV/RISCVCallingConv.cpp
index 14c74e48bdc7e8..25572376ead0dc 100644
--- a/llvm/lib/Target/RISCV/RISCVCallingConv.cpp
+++ b/llvm/lib/Target/RISCV/RISCVCallingConv.cpp
@@ -440,7 +440,7 @@ static bool CC_RISCV_Impl(unsigned ValNo, MVT ValVT, MVT LocVT,
   bool AllowFPRForF64 = false;
 
   RISCVABI::ABI ABI = Subtarget.getTargetABI();
-  assert(ABI != RISCVABI::ABI_Unknown && !RISCVABI::isPurecap(ABI) &&
+  assert(ABI != RISCVABI::ABI::Unknown && !RISCVABI::isPurecap(ABI) &&
          "Unexpected ABI");
   bool IsDoubleFPABI = RISCVABI::isDoubleFP(ABI);
   if (IsDoubleFPABI || RISCVABI::isSingleFP(ABI))
@@ -527,7 +527,7 @@ static bool CC_RISCV_Impl(unsigned ValNo, MVT ValVT, MVT LocVT,
   unsigned TwoXLenInBytes = (2 * XLen) / 8;
   if (ArgFlags.isVarArg() && ArgFlags.getNonZeroOrigAlign() == TwoXLenInBytes &&
       DL.getTypeAllocSize(OrigTy) == TwoXLenInBytes &&
-      ABI != RISCVABI::ABI_ILP32E) {
+      ABI != RISCVABI::ABI::ILP32E) {
     unsigned RegIdx = State.getFirstUnallocated(ArgGPRs);
     // Skip 'odd' register if necessary.
     if (RegIdx != std::size(ArgGPRs) && RegIdx % 2 == 1)
diff --git a/llvm/lib/Target/RISCV/RISCVISelLowering.cpp b/llvm/lib/Target/RISCV/RISCVISelLowering.cpp
index bb4a273460bf4c..294ee4b3996b08 100644
--- a/llvm/lib/Target/RISCV/RISCVISelLowering.cpp
+++ b/llvm/lib/Target/RISCV/RISCVISelLowering.cpp
@@ -73,7 +73,7 @@ RISCVTargetLowering::RISCVTargetLowering(const TargetMachine &TM,
   RISCVABI::ABI ABI = Subtarget.getTargetABI();
   // Note: Hard-float ABIs that don't match the F/D extensions are already
   // rejected/ by RISCVABI::computeTargetABI() during subtarget construction.
-  assert(ABI != RISCVABI::ABI_Unknown && "Improperly initialised target ABI");
+  assert(ABI != RISCVABI::ABI::Unknown && "Improperly initialised target ABI");
 
   if (RISCVABI::isPurecap(ABI))
     reportFatalUsageError("Don't know how to lower this ABI");
diff --git a/llvm/lib/Target/RISCV/RISCVRegisterInfo.cpp b/llvm/lib/Target/RISCV/RISCVRegisterInfo.cpp
index 63d64b0febc85f..45fb74939b752a 100644
--- a/llvm/lib/Target/RISCV/RISCVRegisterInfo.cpp
+++ b/llvm/lib/Target/RISCV/RISCVRegisterInfo.cpp
@@ -89,7 +89,7 @@ RISCVRegisterInfo::getCalleeSavedRegs(const MachineFunction *MF) const {
       Subtarget.hasVInstructions();
 
   RISCVABI::ABI ABI = Subtarget.getTargetABI();
-  assert(ABI != RISCVABI::ABI_Unknown && !RISCVABI::isPurecap(ABI) &&
+  assert(ABI != RISCVABI::ABI::Unknown && !RISCVABI::isPurecap(ABI) &&
          "Unrecognized ABI");
   if (RISCVABI::isRVE(ABI))
     return CSR_ILP32E_LP64E_SaveList;
@@ -886,7 +886,7 @@ RISCVRegisterInfo::getCallPreservedMask(const MachineFunction & MF,
   if (CC == CallingConv::GHC)
     return CSR_NoRegs_RegMask;
   RISCVABI::ABI ABI = Subtarget.getTargetABI();
-  assert(ABI != RISCVABI::ABI_Unknown && !RISCVABI::isPurecap(ABI) &&
+  assert(ABI != RISCVABI::ABI::Unknown && !RISCVABI::isPurecap(ABI) &&
          "Unrecognized ABI");
   if (CC == CallingConv::PreserveMost) {
     if (RISCVABI::isRVE(ABI))
diff --git a/llvm/lib/Target/RISCV/RISCVSubtarget.h b/llvm/lib/Target/RISCV/RISCVSubtarget.h
index 7d75087a24667b..3d49fe4e748cbc 100644
--- a/llvm/lib/Target/RISCV/RISCVSubtarget.h
+++ b/llvm/lib/Target/RISCV/RISCVSubtarget.h
@@ -123,7 +123,7 @@ class RISCVSubtarget : public RISCVGenSubtargetInfo {
   unsigned RVVVectorBitsMin;
   unsigned RVVVectorBitsMax;
   uint8_t MaxInterleaveFactor = 2;
-  RISCVABI::ABI TargetABI = RISCVABI::ABI_Unknown;
+  RISCVABI::ABI TargetABI = RISCVABI::ABI::Unknown;
   std::bitset<RISCV::NUM_TARGET_REGS> UserReservedRegister;
   const RISCVTuneInfoTable::RISCVTuneInfo *TuneInfo;
 
diff --git a/llvm/unittests/Target/RISCV/RISCVBaseInfoTest.cpp b/llvm/unittests/Target/RISCV/RISCVBaseInfoTest.cpp
index efd17fc4ecc3bb..78a20e064127e6 100644
--- a/llvm/unittests/Target/RISCV/RISCVBaseInfoTest.cpp
+++ b/llvm/unittests/Target/RISCV/RISCVBaseInfoTest.cpp
@@ -49,36 +49,36 @@ std::string computeTargetABIError(StringRef TripleName, StringRef FeatureStr,
 }
 
 TEST(ComputeTargetABI, SelectsExpectedABI) {
-  EXPECT_EQ(computeTargetABI("riscv32", ""), RISCVABI::ABI_ILP32);
-  EXPECT_EQ(computeTargetABI("riscv32", "+f"), RISCVABI::ABI_ILP32F);
-  EXPECT_EQ(computeTargetABI("riscv32", "+f,+d"), RISCVABI::ABI_ILP32D);
-  EXPECT_EQ(computeTargetABI("riscv64", ""), RISCVABI::ABI_LP64);
-  EXPECT_EQ(computeTargetABI("riscv64", "+f"), RISCVABI::ABI_LP64F);
-  EXPECT_EQ(computeTargetABI("riscv64", "+f,+d"), RISCVABI::ABI_LP64D);
+  EXPECT_EQ(computeTargetABI("riscv32", ""), RISCVABI::ABI::ILP32);
+  EXPECT_EQ(computeTargetABI("riscv32", "+f"), RISCVABI::ABI::ILP32F);
+  EXPECT_EQ(computeTargetABI("riscv32", "+f,+d"), RISCVABI::ABI::ILP32D);
+  EXPECT_EQ(computeTargetABI("riscv64", ""), RISCVABI::ABI::LP64);
+  EXPECT_EQ(computeTargetABI("riscv64", "+f"), RISCVABI::ABI::LP64F);
+  EXPECT_EQ(computeTargetABI("riscv64", "+f,+d"), RISCVABI::ABI::LP64D);
 
   // RVY targets default to the capability ABI.
   EXPECT_EQ(computeTargetABI("riscv32", "+experimental-y"),
-            RISCVABI::ABI_IL32PC64);
+            RISCVABI::ABI::IL32PC64);
   EXPECT_EQ(computeTargetABI("riscv32", "+experimental-y,+f"),
-            RISCVABI::ABI_IL32PC64F);
+            RISCVABI::ABI::IL32PC64F);
   EXPECT_EQ(computeTargetABI("riscv32", "+experimental-y,+f,+d"),
-            RISCVABI::ABI_IL32PC64D);
+            RISCVABI::ABI::IL32PC64D);
   EXPECT_EQ(computeTargetABI("riscv64", "+experimental-y"),
-            RISCVABI::ABI_L64PC128);
+            RISCVABI::ABI::L64PC128);
   EXPECT_EQ(computeTargetABI("riscv64", "+experimental-y,+f"),
-            RISCVABI::ABI_L64PC128F);
+            RISCVABI::ABI::L64PC128F);
   EXPECT_EQ(computeTargetABI("riscv64", "+experimental-y,+f,+d"),
-            RISCVABI::ABI_L64PC128D);
+            RISCVABI::ABI::L64PC128D);
 
   // An explicit ABI overrides the default.
   EXPECT_EQ(computeTargetABI("riscv32", "+experimental-y", /*ABIName=*/"ilp32"),
-            RISCVABI::ABI_ILP32);
+            RISCVABI::ABI::ILP32);
   EXPECT_EQ(computeTargetABI("riscv64", "+experimental-y,+f,+d",
                              /*ABIName=*/"lp64d"),
-            RISCVABI::ABI_LP64D);
+            RISCVABI::ABI::LP64D);
 
   // CHERIoT always selects the cheriot ABI by default.
-  EXPECT_EQ(computeTargetABI("riscv32", "+xcheriot"), RISCVABI::ABI_CHERIOT);
+  EXPECT_EQ(computeTargetABI("riscv32", "+xcheriot"), RISCVABI::ABI::CHERIOT);
 }
 
 TEST(ComputeTargetABI, ReportsInvalidExplicitABI) {

``````````

</details>


https://github.com/llvm/llvm-project/pull/239007


More information about the llvm-branch-commits mailing list