GlobalISel: Prepare to allow other target unit tests

[arsenm]

Summary

Currently all GlobalISel unittests use a hardcoded AArch64 target
machine. Factor this so I can write some for AMDGPU specific known
bits unittests.

[dsanders]

LGTM aside from that orphaned comment

llvm/unittests/CodeGen/GlobalISel/GISelMITest.h

56–57

The function this comment refers to is gone

[arsenm]

58f843a5b3d672f703c91af92cb2fd805f09ccbc

llvm/unittests/CodeGen/GlobalISel/CSETest.cpp

 //===- CSETest.cpp -----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "GISelMITest.h"
 #include "llvm/CodeGen/GlobalISel/CSEMIRBuilder.h"
 
 namespace {
 
-TEST_F(GISelMITest, TestCSE) {
+TEST_F(AArch64GISelMITest, TestCSE) {
   setUp();
   if (!TM)
     return;
 
   LLT s16{LLT::scalar(16)};
   LLT s32{LLT::scalar(32)};
   auto MIBInput = B.buildInstr(TargetOpcode::G_TRUNC, {s16}, {Copies[0]});
   auto MIBInput1 = B.buildInstr(TargetOpcode::G_TRUNC, {s16}, {Copies[1]});
TEST_F(AArch64GISelMITest, TestCSE) {
   EXPECT_TRUE(&*MIBUnmerge == &*MIBUnmerge2);
 
   // Check G_IMPLICIT_DEF
   auto Undef0 = CSEB.buildUndef(s32);
   auto Undef1 = CSEB.buildUndef(s32);
   EXPECT_EQ(&*Undef0, &*Undef1);
 }
 
-TEST_F(GISelMITest, TestCSEConstantConfig) {
+TEST_F(AArch64GISelMITest, TestCSEConstantConfig) {
   setUp();
   if (!TM)
     return;
 
   LLT s16{LLT::scalar(16)};
   auto MIBInput = B.buildInstr(TargetOpcode::G_TRUNC, {s16}, {Copies[0]});
   auto MIBAdd = B.buildInstr(TargetOpcode::G_ADD, {s16}, {MIBInput, MIBInput});
   auto MIBZero = B.buildConstant(s16, 0);

llvm/unittests/CodeGen/GlobalISel/ConstantFoldingTest.cpp

 #include "llvm/CodeGen/GlobalISel/Utils.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 
 namespace {
 
-TEST_F(GISelMITest, FoldWithBuilder) {
+TEST_F(AArch64GISelMITest, FoldWithBuilder) {
   setUp();
   if (!TM)
     return;
   // Try to use the FoldableInstructionsBuilder to build binary ops.
   ConstantFoldingMIRBuilder CFB(B.getState());
   LLT s32 = LLT::scalar(32);
   int64_t Cst;
   auto MIBCAdd =
auto MIBCSext2 =
       CFB1.buildInstr(TargetOpcode::G_SEXT_INREG, {s32},
                       {CFB1.buildConstant(s32, 0x80), uint64_t(8)});
   // This should be a constant now.
   match = mi_match(MIBCSext2.getReg(0), *MRI, m_ICst(Cst));
   EXPECT_TRUE(match);
   EXPECT_EQ(-0x80, Cst);
 }
 
-TEST_F(GISelMITest, FoldBinOp) {
+TEST_F(AArch64GISelMITest, FoldBinOp) {
   setUp();
   if (!TM)
     return;
 
   LLT s32{LLT::scalar(32)};
   auto MIBCst1 = B.buildConstant(s32, 16);
   auto MIBCst2 = B.buildConstant(s32, 9);
   auto MIBFCst1 = B.buildFConstant(s32, 1.0000001);
TEST_F(AArch64GISelMITest, FoldBinOp) {
   Optional<APInt> FoldGSremMix =
       ConstantFoldBinOp(TargetOpcode::G_SREM, MIBCst1.getReg(0),
                         MIBFCst2.getReg(0), *MRI);
   EXPECT_TRUE(FoldGSremMix.hasValue());
   EXPECT_EQ(16ULL, FoldGSremMix.getValue().getLimitedValue());
 }
 
 } // namespace
 No newline at end of file

llvm/unittests/CodeGen/GlobalISel/GISelMITest.h

 namespace llvm {
 std::ostream &
 operator<<(std::ostream &OS, const LLT Ty);
 
 std::ostream &
 operator<<(std::ostream &OS, const MachineFunction &MF);
 }
 
 /// Create a TargetMachine. As we lack a dedicated always available target for
 /// unittests, we go for "AArch64".
-static std::unique_ptr<LLVMTargetMachine> createTargetMachine() {
-  Triple TargetTriple("aarch64--");
-  std::string Error;
-  const Target *T = TargetRegistry::lookupTarget("", TargetTriple, Error);
-  if (!T)
-    return nullptr;
-
-  TargetOptions Options;
-  return std::unique_ptr<LLVMTargetMachine>(
-      static_cast<LLVMTargetMachine *>(T->createTargetMachine(
-          "AArch64", "", "", Options, None, None, CodeGenOpt::Aggressive)));
-}
-
 static std::unique_ptr<Module> parseMIR(LLVMContext &Context,
                                         std::unique_ptr<MIRParser> &MIR,
                                         const TargetMachine &TM,
                                         StringRef MIRCode, const char *FuncName,
                                         MachineModuleInfo &MMI) {
   SMDiagnostic Diagnostic;
   std::unique_ptr<MemoryBuffer> MBuffer = MemoryBuffer::getMemBuffer(MIRCode);
   MIR = createMIRParser(std::move(MBuffer), Context);
   if (!MIR)
     return nullptr;
 
   std::unique_ptr<Module> M = MIR->parseIRModule();
   if (!M)
     return nullptr;
 
   M->setDataLayout(TM.createDataLayout());
 
   if (MIR->parseMachineFunctions(*M, MMI))
     return nullptr;
 
   return M;
 }
-
 static std::pair<std::unique_ptr<Module>, std::unique_ptr<MachineModuleInfo>>
 createDummyModule(LLVMContext &Context, const LLVMTargetMachine &TM,
-                  StringRef MIRFunc) {
-  SmallString<512> S;
-  StringRef MIRString = (Twine(R"MIR(
----
-...
-name: func
-tracksRegLiveness: true
-registers:
-  - { id: 0, class: _ }
-  - { id: 1, class: _ }
-  - { id: 2, class: _ }
-  - { id: 3, class: _ }
-body: |
-  bb.1:
-    liveins: $x0, $x1, $x2, $x4
-
-    %0(s64) = COPY $x0
-    %1(s64) = COPY $x1
-    %2(s64) = COPY $x2
-)MIR") + Twine(MIRFunc) + Twine("...\n"))
-                            .toNullTerminatedStringRef(S);
+                  StringRef MIRString, const char *FuncName) {
   std::unique_ptr<MIRParser> MIR;
   auto MMI = std::make_unique<MachineModuleInfo>(&TM);
   std::unique_ptr<Module> M =
-      parseMIR(Context, MIR, TM, MIRString, "func", *MMI);
+      parseMIR(Context, MIR, TM, MIRString, FuncName, *MMI);
   return make_pair(std::move(M), std::move(MMI));
 }
 
 static MachineFunction *getMFFromMMI(const Module *M,
                                      const MachineModuleInfo *MMI) {
   Function *F = M->getFunction("func");
   auto *MF = MMI->getMachineFunction(*F);
   return MF;
 }
 
 static void collectCopies(SmallVectorImpl<Register> &Copies,
                           MachineFunction *MF) {
   for (auto &MBB : *MF)
     for (MachineInstr &MI : MBB) {
       if (MI.getOpcode() == TargetOpcode::COPY)
         Copies.push_back(MI.getOperand(0).getReg());
     }
 }
 
 class GISelMITest : public ::testing::Test {
 protected:
   GISelMITest() : ::testing::Test() {}
+
+  /// Prepare a target specific LLVMTargetMachine.
+  virtual std::unique_ptr<LLVMTargetMachine> createTargetMachine() const = 0;
+
+  /// Get the stub sample MIR test function.
+  virtual void getTargetTestModuleString(SmallString<512> &S,
+                                         StringRef MIRFunc) const = 0;
+
   void setUp(StringRef ExtraAssembly = "") {
     TM = createTargetMachine();
     if (!TM)
       return;
-    ModuleMMIPair = createDummyModule(Context, *TM, ExtraAssembly);
+
+    SmallString<512> MIRString;
+    getTargetTestModuleString(MIRString, ExtraAssembly);
+
+    ModuleMMIPair = createDummyModule(Context, *TM, MIRString, "func");
     MF = getMFFromMMI(ModuleMMIPair.first.get(), ModuleMMIPair.second.get());
     collectCopies(Copies, MF);
     EntryMBB = &*MF->begin();
     B.setMF(*MF);
     MRI = &MF->getRegInfo();
     B.setInsertPt(*EntryMBB, EntryMBB->end());
   }
+
   LLVMContext Context;
   std::unique_ptr<LLVMTargetMachine> TM;
   MachineFunction *MF;
   std::pair<std::unique_ptr<Module>, std::unique_ptr<MachineModuleInfo>>
       ModuleMMIPair;
   SmallVector<Register, 4> Copies;
   MachineBasicBlock *EntryMBB;
   MachineIRBuilder B;
   MachineRegisterInfo *MRI;
 };
 
+class AArch64GISelMITest : public GISelMITest {
+  std::unique_ptr<LLVMTargetMachine> createTargetMachine() const override;
+  void getTargetTestModuleString(SmallString<512> &S,
+                                 StringRef MIRFunc) const override;
+};
+
 #define DefineLegalizerInfo(Name, SettingUpActionsBlock)                       \
   class Name##Info : public LegalizerInfo {                                    \
   public:                                                                      \
     Name##Info(const TargetSubtargetInfo &ST) {                                \
       using namespace TargetOpcode;                                            \
       const LLT s8 = LLT::scalar(8);                                           \
       (void)s8;                                                                \
       const LLT s16 = LLT::scalar(16);                                         \

llvm/unittests/CodeGen/GlobalISel/GISelMITest.cpp

operator<<(std::ostream &OS, const MachineFunction &MF) {
   std::string Repr;
   raw_string_ostream SS{Repr};
   MF.print(SS);
   OS << SS.str();
   return OS;
 }
 
 }
+
+std::unique_ptr<LLVMTargetMachine>
+AArch64GISelMITest::createTargetMachine() const {
+  Triple TargetTriple("aarch64--");
+  std::string Error;
+  const Target *T = TargetRegistry::lookupTarget("", TargetTriple, Error);
+  if (!T)
+    return nullptr;
+
+  TargetOptions Options;
+  return std::unique_ptr<LLVMTargetMachine>(
+      static_cast<LLVMTargetMachine *>(T->createTargetMachine(
+          "AArch64", "", "", Options, None, None, CodeGenOpt::Aggressive)));
+}
+
+void AArch64GISelMITest::getTargetTestModuleString(SmallString<512> &S,
+                                                   StringRef MIRFunc) const {
+  (Twine(R"MIR(
+---
+...
+name: func
+tracksRegLiveness: true
+registers:
+  - { id: 0, class: _ }
+  - { id: 1, class: _ }
+  - { id: 2, class: _ }
+  - { id: 3, class: _ }
+body: |
+  bb.1:
+    liveins: $x0, $x1, $x2, $x4
+
+    %0(s64) = COPY $x0
+    %1(s64) = COPY $x1
+    %2(s64) = COPY $x2
+)MIR") +
+   Twine(MIRFunc) + Twine("...\n"))
+      .toNullTerminatedStringRef(S);
+}

llvm/unittests/CodeGen/GlobalISel/KnownBitsTest.cpp

 //===- KnownBitsTest.cpp -------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "GISelMITest.h"
 #include "llvm/CodeGen/GlobalISel/GISelKnownBits.h"
 #include "llvm/CodeGen/GlobalISel/MachineIRBuilder.h"
 
-TEST_F(GISelMITest, TestKnownBitsCst) {
+TEST_F(AArch64GISelMITest, TestKnownBitsCst) {
   StringRef MIRString = "  %3:_(s8) = G_CONSTANT i8 1\n"
                         "  %4:_(s8) = COPY %3\n";
   setUp(MIRString);
   if (!TM)
     return;
   unsigned CopyReg = Copies[Copies.size() - 1];
   MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);
   unsigned SrcReg = FinalCopy->getOperand(1).getReg();
   unsigned DstReg = FinalCopy->getOperand(0).getReg();
   GISelKnownBits Info(*MF);
   KnownBits Res = Info.getKnownBits(SrcReg);
   EXPECT_EQ((uint64_t)1, Res.One.getZExtValue());
   EXPECT_EQ((uint64_t)0xfe, Res.Zero.getZExtValue());
 
   KnownBits Res2 = Info.getKnownBits(DstReg);
   EXPECT_EQ(Res.One.getZExtValue(), Res2.One.getZExtValue());
   EXPECT_EQ(Res.Zero.getZExtValue(), Res2.Zero.getZExtValue());
 }
 
-TEST_F(GISelMITest, TestKnownBitsCstWithClass) {
+TEST_F(AArch64GISelMITest, TestKnownBitsCstWithClass) {
   StringRef MIRString = "  %10:gpr32 = MOVi32imm 1\n"
                         "  %4:_(s32) = COPY %10\n";
   setUp(MIRString);
   if (!TM)
     return;
   unsigned CopyReg = Copies[Copies.size() - 1];
   MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);
   unsigned SrcReg = FinalCopy->getOperand(1).getReg();
TEST_F(AArch64GISelMITest, TestKnownBitsCstWithClass) {
   // did reveal the size of %3.
   EXPECT_EQ((uint64_t)32, Res2.getBitWidth());
   EXPECT_EQ(Res.One.getZExtValue(), Res2.One.getZExtValue());
   EXPECT_EQ(Res.Zero.getZExtValue(), Res2.Zero.getZExtValue());
 }
 
 // Check that we are able to track bits through PHIs
 // and get the intersections of everything we know on each operand.
-TEST_F(GISelMITest, TestKnownBitsCstPHI) {
+TEST_F(AArch64GISelMITest, TestKnownBitsCstPHI) {
   StringRef MIRString = "  bb.10:\n"
                         "  %10:_(s8) = G_CONSTANT i8 3\n"
                         "  %11:_(s1) = G_IMPLICIT_DEF\n"
                         "  G_BRCOND %11(s1), %bb.11\n"
                         "  G_BR %bb.12\n"
                         "\n"
                         "  bb.11:\n"
                         "  %12:_(s8) = G_CONSTANT i8 2\n"
TEST_F(AArch64GISelMITest, TestKnownBitsCstPHI) {
   KnownBits Res2 = Info.getKnownBits(DstReg);
   EXPECT_EQ(Res.One.getZExtValue(), Res2.One.getZExtValue());
   EXPECT_EQ(Res.Zero.getZExtValue(), Res2.Zero.getZExtValue());
 }
 
 // Check that we report we know nothing when we hit a
 // non-generic register.
 // Note: this could be improved though!
-TEST_F(GISelMITest, TestKnownBitsCstPHIToNonGenericReg) {
+TEST_F(AArch64GISelMITest, TestKnownBitsCstPHIToNonGenericReg) {
   StringRef MIRString = "  bb.10:\n"
                         "  %10:gpr32 = MOVi32imm 3\n"
                         "  %11:_(s1) = G_IMPLICIT_DEF\n"
                         "  G_BRCOND %11(s1), %bb.11\n"
                         "  G_BR %bb.12\n"
                         "\n"
                         "  bb.11:\n"
                         "  %12:_(s8) = G_CONSTANT i8 2\n"

 }
 
 // Check that we know nothing when at least one value of a PHI
 // comes from something we cannot analysis.
 // This test is not particularly interesting, it is just
 // here to cover the code that stops the analysis of PHIs
 // earlier. In that case, we would not even look at the
 // second incoming value.
-TEST_F(GISelMITest, TestKnownBitsUnknownPHI) {
+TEST_F(AArch64GISelMITest, TestKnownBitsUnknownPHI) {
   StringRef MIRString =
       "  bb.10:\n"
       "  %10:_(s64) = COPY %0\n"
       "  %11:_(s1) = G_IMPLICIT_DEF\n"
       "  G_BRCOND %11(s1), %bb.11\n"
       "  G_BR %bb.12\n"
       "\n"
       "  bb.11:\n"
TEST_F(AArch64GISelMITest, TestKnownBitsUnknownPHI) {
   EXPECT_EQ(Res.One.getZExtValue(), Res2.One.getZExtValue());
   EXPECT_EQ(Res.Zero.getZExtValue(), Res2.Zero.getZExtValue());
 }
 
 // Check that we manage to process PHIs that loop on themselves.
 // For now, the analysis just stops and assumes it knows nothing,
 // eventually we could teach it how to properly track phis that
 // loop back.
-TEST_F(GISelMITest, TestKnownBitsCstPHIWithLoop) {
+TEST_F(AArch64GISelMITest, TestKnownBitsCstPHIWithLoop) {
   StringRef MIRString =
       "  bb.10:\n"
       "  %10:_(s8) = G_CONSTANT i8 3\n"
       "  %11:_(s1) = G_IMPLICIT_DEF\n"
       "  G_BRCOND %11(s1), %bb.11\n"
       "  G_BR %bb.12\n"
       "\n"
       "  bb.11:\n"

 // that %14's zero known bits are actually at least what we know
 // for %10, right shifted by one.
 // However, this process is super expensive compile-time wise and
 // we don't want to reach that conclusion while playing with max depth.
 // For now, the analysis just stops and assumes it knows nothing
 // on PHIs, but eventually we could teach it how to properly track
 // phis that loop back without relying on the luck effect of max
 // depth.
-TEST_F(GISelMITest, TestKnownBitsDecreasingCstPHIWithLoop) {
+TEST_F(AArch64GISelMITest, TestKnownBitsDecreasingCstPHIWithLoop) {
   StringRef MIRString = "  bb.10:\n"
                         "  %10:_(s8) = G_CONSTANT i8 5\n"
                         "  %11:_(s8) = G_CONSTANT i8 1\n"
                         "\n"
                         "  bb.12:\n"
                         "  %13:_(s8) = PHI %10(s8), %bb.10, %14(s8), %bb.12\n"
                         "  %14:_(s8) = G_LSHR %13, %11\n"
                         "  %15:_(s8) = COPY %14\n"
TEST_F(AArch64GISelMITest, TestKnownBitsDecreasingCstPHIWithLoop) {
   // up to 0xFC (count leading zero of 5, + 1).
   EXPECT_EQ((uint64_t)0xC0, Res.Zero.getZExtValue());
 
   KnownBits Res2 = Info.getKnownBits(DstReg);
   EXPECT_EQ(Res.One.getZExtValue(), Res2.One.getZExtValue());
   EXPECT_EQ(Res.Zero.getZExtValue(), Res2.Zero.getZExtValue());
 }
 
-TEST_F(GISelMITest, TestKnownBitsPtrToIntViceVersa) {
+TEST_F(AArch64GISelMITest, TestKnownBitsPtrToIntViceVersa) {
   StringRef MIRString = "  %3:_(s16) = G_CONSTANT i16 256\n"
                         "  %4:_(p0) = G_INTTOPTR %3\n"
                         "  %5:_(s32) = G_PTRTOINT %4\n"
                         "  %6:_(s32) = COPY %5\n";
   setUp(MIRString);
   if (!TM)
     return;
   unsigned CopyReg = Copies[Copies.size() - 1];
   MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);
   unsigned SrcReg = FinalCopy->getOperand(1).getReg();
   GISelKnownBits Info(*MF);
   KnownBits Res = Info.getKnownBits(SrcReg);
   EXPECT_EQ(256u, Res.One.getZExtValue());
   EXPECT_EQ(0xfffffeffu, Res.Zero.getZExtValue());
 }
-TEST_F(GISelMITest, TestKnownBitsXOR) {
+TEST_F(AArch64GISelMITest, TestKnownBitsXOR) {
   StringRef MIRString = "  %3:_(s8) = G_CONSTANT i8 4\n"
                         "  %4:_(s8) = G_CONSTANT i8 7\n"
                         "  %5:_(s8) = G_XOR %3, %4\n"
                         "  %6:_(s8) = COPY %5\n";
   setUp(MIRString);
   if (!TM)
     return;
   unsigned CopyReg = Copies[Copies.size() - 1];
   MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);
   unsigned SrcReg = FinalCopy->getOperand(1).getReg();
   GISelKnownBits Info(*MF);
   KnownBits Res = Info.getKnownBits(SrcReg);
   EXPECT_EQ(3u, Res.One.getZExtValue());
   EXPECT_EQ(252u, Res.Zero.getZExtValue());
 }
 
-TEST_F(GISelMITest, TestKnownBits) {
+TEST_F(AArch64GISelMITest, TestKnownBits) {
 
   StringRef MIR = "  %3:_(s32) = G_TRUNC %0\n"
                   "  %4:_(s32) = G_TRUNC %1\n"
                   "  %5:_(s32) = G_CONSTANT i32 5\n"
                   "  %6:_(s32) = G_CONSTANT i32 24\n"
                   "  %7:_(s32) = G_CONSTANT i32 28\n"
                   "  %14:_(p0) = G_INTTOPTR %7\n"
                   "  %16:_(s32) = G_PTRTOINT %14\n"
TEST_F(AArch64GISelMITest, TestKnownBits) {
   KnownBits Known = Info.getKnownBits(SrcReg);
   EXPECT_FALSE(Known.hasConflict());
   EXPECT_EQ(0u, Known.One.getZExtValue());
   EXPECT_EQ(31u, Known.Zero.getZExtValue());
   APInt Zeroes = Info.getKnownZeroes(SrcReg);
   EXPECT_EQ(Known.Zero, Zeroes);
 }
 
-TEST_F(GISelMITest, TestSignBitIsZero) {
+TEST_F(AArch64GISelMITest, TestSignBitIsZero) {
   setUp();
   if (!TM)
     return;
 
   const LLT S32 = LLT::scalar(32);
   auto SignBit = B.buildConstant(S32, 0x80000000);
   auto Zero = B.buildConstant(S32, 0);
 
   GISelKnownBits KnownBits(*MF);
 
   EXPECT_TRUE(KnownBits.signBitIsZero(Zero.getReg(0)));
   EXPECT_FALSE(KnownBits.signBitIsZero(SignBit.getReg(0)));
 }
 
-TEST_F(GISelMITest, TestNumSignBitsConstant) {
+TEST_F(AArch64GISelMITest, TestNumSignBitsConstant) {
   StringRef MIRString = "  %3:_(s8) = G_CONSTANT i8 1\n"
                         "  %4:_(s8) = COPY %3\n"
 
                         "  %5:_(s8) = G_CONSTANT i8 -1\n"
                         "  %6:_(s8) = COPY %5\n"
 
                         "  %7:_(s8) = G_CONSTANT i8 127\n"
                         "  %8:_(s8) = COPY %7\n"
TEST_F(AArch64GISelMITest, TestNumSignBitsConstant) {
   GISelKnownBits Info(*MF);
   EXPECT_EQ(7u, Info.computeNumSignBits(CopyReg1));
   EXPECT_EQ(8u, Info.computeNumSignBits(CopyRegNeg1));
   EXPECT_EQ(1u, Info.computeNumSignBits(CopyReg127));
   EXPECT_EQ(2u, Info.computeNumSignBits(CopyReg32));
   EXPECT_EQ(3u, Info.computeNumSignBits(CopyRegNeg32));
 }
 
-TEST_F(GISelMITest, TestNumSignBitsSext) {
+TEST_F(AArch64GISelMITest, TestNumSignBitsSext) {
   StringRef MIRString = "  %3:_(p0) = G_IMPLICIT_DEF\n"
                         "  %4:_(s8) = G_LOAD %3 :: (load 1)\n"
                         "  %5:_(s32) = G_SEXT %4\n"
                         "  %6:_(s32) = COPY %5\n"
 
                         "  %7:_(s8) = G_CONSTANT i8 -1\n"
                         "  %8:_(s32) = G_SEXT %7\n"
                         "  %9:_(s32) = COPY %8\n";
   setUp(MIRString);
   if (!TM)
     return;
   Register CopySextLoad = Copies[Copies.size() - 2];
   Register CopySextNeg1 = Copies[Copies.size() - 1];
 
   GISelKnownBits Info(*MF);
   EXPECT_EQ(25u, Info.computeNumSignBits(CopySextLoad));
   EXPECT_EQ(32u, Info.computeNumSignBits(CopySextNeg1));
 }
 
-TEST_F(GISelMITest, TestNumSignBitsTrunc) {
+TEST_F(AArch64GISelMITest, TestNumSignBitsTrunc) {
   StringRef MIRString = "  %3:_(p0) = G_IMPLICIT_DEF\n"
                         "  %4:_(s32) = G_LOAD %3 :: (load 4)\n"
                         "  %5:_(s8) = G_TRUNC %4\n"
                         "  %6:_(s8) = COPY %5\n"
 
                         "  %7:_(s32) = G_CONSTANT i32 -1\n"
                         "  %8:_(s8) = G_TRUNC %7\n"
                         "  %9:_(s8) = COPY %8\n"

llvm/unittests/CodeGen/GlobalISel/LegalizerHelperTest.cpp

public:
   void changingInstr(MachineInstr &MI) override {}
   void changedInstr(MachineInstr &MI) override {}
   void createdInstr(MachineInstr &MI) override {}
   void erasingInstr(MachineInstr &MI) override {}
 };
 
 // Test CTTZ expansion when CTTZ_ZERO_UNDEF is legal or custom,
 // in which case it becomes CTTZ_ZERO_UNDEF with select.
-TEST_F(GISelMITest, LowerBitCountingCTTZ0) {
+TEST_F(AArch64GISelMITest, LowerBitCountingCTTZ0) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_CTTZ_ZERO_UNDEF).legalFor({{s32, s64}});
   });
TEST_F(AArch64GISelMITest, LowerBitCountingCTTZ0) {
   CHECK: [[SEL:%[0-9]+]]:_(s32) = G_SELECT [[CMP]]:_(s1), [[SIXTY4]]:_, [[CZU]]
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
 // CTTZ expansion in terms of CTLZ
-TEST_F(GISelMITest, LowerBitCountingCTTZ1) {
+TEST_F(AArch64GISelMITest, LowerBitCountingCTTZ1) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_CTLZ).legalFor({{s64, s64}});
   });
TEST_F(AArch64GISelMITest, LowerBitCountingCTTZ1) {
   CHECK: G_SUB [[CST64]]:_, [[CTLZ]]:_
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
 // CTLZ scalar narrowing
-TEST_F(GISelMITest, NarrowScalarCTLZ) {
+TEST_F(AArch64GISelMITest, NarrowScalarCTLZ) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_CTLZ).legalFor({{s32, s32}});
   });
TEST_F(AArch64GISelMITest, NarrowScalarCTLZ) {
   CHECK: %{{[0-9]+}}:_(s32) = G_SELECT [[CMP]]:_(s1), [[ADD]]:_, [[CTLZ_HI]]:_
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
 // CTTZ scalar narrowing
-TEST_F(GISelMITest, NarrowScalarCTTZ) {
+TEST_F(AArch64GISelMITest, NarrowScalarCTTZ) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_CTTZ).legalFor({{s32, s64}});
   });
TEST_F(AArch64GISelMITest, NarrowScalarCTTZ) {
   CHECK: %{{[0-9]+}}:_(s32) = G_SELECT [[CMP]]:_(s1), [[ADD]]:_, [[CTTZ_LO]]:_
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
 // CTTZ expansion in terms of CTPOP
-TEST_F(GISelMITest, LowerBitCountingCTTZ2) {
+TEST_F(AArch64GISelMITest, LowerBitCountingCTTZ2) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_CTPOP).legalFor({{s64, s64}});
   });
TEST_F(AArch64GISelMITest, LowerBitCountingCTTZ2) {
   CHECK: [[POP:%[0-9]+]]:_(s64) = G_CTPOP [[AND1]]
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
 // CTPOP widening.
-TEST_F(GISelMITest, WidenBitCountingCTPOP1) {
+TEST_F(AArch64GISelMITest, WidenBitCountingCTPOP1) {
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
       getActionDefinitionsBuilder(G_CTPOP).legalFor({{s16, s16}});
     });
 
TEST_F(AArch64GISelMITest, WidenBitCountingCTPOP1) {
   CHECK: [[CTPOP:%[0-9]+]]:_(s16) = G_CTPOP [[ZEXT]]
   CHECK: [[COPY:%[0-9]+]]:_(s16) = COPY [[CTPOP]]:_(s16)
   )";
 
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
 // Test a strange case where the result is wider than the source
-TEST_F(GISelMITest, WidenBitCountingCTPOP2) {
+TEST_F(AArch64GISelMITest, WidenBitCountingCTPOP2) {
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
       getActionDefinitionsBuilder(G_CTPOP).legalFor({{s32, s16}});
     });
 
TEST_F(AArch64GISelMITest, WidenBitCountingCTPOP2) {
   CHECK: [[CTPOP:%[0-9]+]]:_(s16) = G_CTPOP [[ZEXT]]
   CHECK: [[COPY:%[0-9]+]]:_(s32) = G_ZEXT [[CTPOP]]:_(s16)
   )";
 
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
 // CTTZ_ZERO_UNDEF expansion in terms of CTTZ
-TEST_F(GISelMITest, LowerBitCountingCTTZ3) {
+TEST_F(AArch64GISelMITest, LowerBitCountingCTTZ3) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_CTTZ).legalFor({{s64, s64}});
   });
TEST_F(AArch64GISelMITest, LowerBitCountingCTTZ3) {
   CHECK: CTTZ
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
 // CTLZ expansion in terms of CTLZ_ZERO_UNDEF
-TEST_F(GISelMITest, LowerBitCountingCTLZ0) {
+TEST_F(AArch64GISelMITest, LowerBitCountingCTLZ0) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_CTLZ_ZERO_UNDEF).legalFor({{s64, s64}});
   });
TEST_F(AArch64GISelMITest, LowerBitCountingCTLZ0) {
   CHECK: [[SEL:%[0-9]+]]:_(s64) = G_SELECT [[CMP]]:_(s1), [[SIXTY4]]:_, [[CZU]]
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
 // CTLZ expansion in terms of CTLZ_ZERO_UNDEF if the latter is a libcall
-TEST_F(GISelMITest, LowerBitCountingCTLZLibcall) {
+TEST_F(AArch64GISelMITest, LowerBitCountingCTLZLibcall) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_CTLZ_ZERO_UNDEF).libcallFor({{s32, s64}});
   });
TEST_F(AArch64GISelMITest, LowerBitCountingCTLZLibcall) {
   CHECK: [[SEL:%[0-9]+]]:_(s32) = G_SELECT [[CMP]]:_(s1), [[THIRTY2]]:_, [[CZU]]
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
 // CTLZ expansion
-TEST_F(GISelMITest, LowerBitCountingCTLZ1) {
+TEST_F(AArch64GISelMITest, LowerBitCountingCTLZ1) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_CTPOP).legalFor({{s8, s8}});
   });
TEST_F(AArch64GISelMITest, LowerBitCountingCTLZ1) {
   CHECK: [[Sub:%[0-9]+]]:_(s8) = G_SUB [[Len]]:_, [[CTPOP]]:_
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
 // CTLZ widening.
-TEST_F(GISelMITest, WidenBitCountingCTLZ) {
+TEST_F(AArch64GISelMITest, WidenBitCountingCTLZ) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_CTLZ).legalFor({{s16, s16}});
   });
TEST_F(AArch64GISelMITest, WidenBitCountingCTLZ) {
   CHECK: [[Trunc:%[0-9]+]]:_(s8) = G_TRUNC [[Sub]]
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
 // CTLZ_ZERO_UNDEF widening.
-TEST_F(GISelMITest, WidenBitCountingCTLZZeroUndef) {
+TEST_F(AArch64GISelMITest, WidenBitCountingCTLZZeroUndef) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_CTLZ_ZERO_UNDEF).legalFor({{s16, s16}});
   });
TEST_F(AArch64GISelMITest, WidenBitCountingCTLZZeroUndef) {
   CHECK: [[Trunc:%[0-9]+]]:_(s8) = G_TRUNC [[Sub]]
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
 // CTPOP widening.
-TEST_F(GISelMITest, WidenBitCountingCTPOP) {
+TEST_F(AArch64GISelMITest, WidenBitCountingCTPOP) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_CTPOP).legalFor({{s16, s16}});
   });
TEST_F(AArch64GISelMITest, WidenBitCountingCTPOP) {
   CHECK: [[Trunc:%[0-9]+]]:_(s8) = G_TRUNC [[Ctpop]]
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
 // CTTZ_ZERO_UNDEF widening.
-TEST_F(GISelMITest, WidenBitCountingCTTZ_ZERO_UNDEF) {
+TEST_F(AArch64GISelMITest, WidenBitCountingCTTZ_ZERO_UNDEF) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_CTTZ_ZERO_UNDEF).legalFor({{s16, s16}});
   });
TEST_F(AArch64GISelMITest, WidenBitCountingCTTZ_ZERO_UNDEF) {
   CHECK: [[Trunc:%[0-9]+]]:_(s8) = G_TRUNC [[CttzZu]]
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
 // CTTZ widening.
-TEST_F(GISelMITest, WidenBitCountingCTTZ) {
+TEST_F(AArch64GISelMITest, WidenBitCountingCTTZ) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_CTTZ).legalFor({{s16, s16}});
   });
TEST_F(AArch64GISelMITest, WidenBitCountingCTTZ) {
   CHECK: [[Cttz:%[0-9]+]]:_(s16) = G_CTTZ [[Or]]
   CHECK: [[Trunc:%[0-9]+]]:_(s8) = G_TRUNC [[Cttz]]
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 // UADDO widening.
-TEST_F(GISelMITest, WidenUADDO) {
+TEST_F(AArch64GISelMITest, WidenUADDO) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_ADD).legalFor({{s16, s16}});
   });
TEST_F(AArch64GISelMITest, WidenUADDO) {
   CHECK: G_TRUNC [[ADD]]
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
 // USUBO widening.
-TEST_F(GISelMITest, WidenUSUBO) {
+TEST_F(AArch64GISelMITest, WidenUSUBO) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_SUB).legalFor({{s16, s16}});
   });
TEST_F(AArch64GISelMITest, WidenUSUBO) {
   CHECK: G_ICMP intpred(ne), [[SUB]]:_(s16), [[AND]]:_
   CHECK: G_TRUNC [[SUB]]
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, FewerElementsAnd) {
+TEST_F(AArch64GISelMITest, FewerElementsAnd) {
   if (!TM)
     return;
 
   const LLT V2S32 = LLT::vector(2, 32);
   const LLT V5S32 = LLT::vector(5, 32);
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
TEST_F(AArch64GISelMITest, FewerElementsAnd) {
   CHECK: [[AND2:%[0-9]+]]:_(s32) = G_AND [[EXTRACT4]]:_, [[EXTRACT5]]:_
   CHECK: [[INSERT2:%[0-9]+]]:_(<5 x s32>) = G_INSERT [[INSERT1]]:_, [[AND2]]:_(s32), 128
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, MoreElementsAnd) {
+TEST_F(AArch64GISelMITest, MoreElementsAnd) {
   if (!TM)
     return;
 
   LLT s32 = LLT::scalar(32);
   LLT v2s32 = LLT::vector(2, 32);
   LLT v6s32 = LLT::vector(6, 32);
 
   LegalizerInfo LI;
TEST_F(AArch64GISelMITest, MoreElementsAnd) {
   CHECK: [[CONCAT1:%[0-9]+]]:_(<6 x s32>) = G_CONCAT_VECTORS [[BITCAST1]]:_(<2 x s32>), [[IMP_DEF1]]:_(<2 x s32>), [[IMP_DEF1]]:_(<2 x s32>)
   CHECK: [[AND:%[0-9]+]]:_(<6 x s32>) = G_AND [[CONCAT0]]:_, [[CONCAT1]]:_
   CHECK: (<2 x s32>) = G_EXTRACT [[AND]]:_(<6 x s32>), 0
   )";
 
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, FewerElementsPhi) {
+TEST_F(AArch64GISelMITest, FewerElementsPhi) {
   if (!TM)
     return;
 
   LLT s1 = LLT::scalar(1);
   LLT s32 = LLT::scalar(32);
   LLT s64 = LLT::scalar(64);
   LLT v2s32 = LLT::vector(2, 32);
   LLT v5s32 = LLT::vector(5, 32);
TEST_F(AArch64GISelMITest, FewerElementsPhi) {
   CHECK: [[INSERT2:%[0-9]+]]:_(<5 x s32>) = G_INSERT [[INSERT1]]:_, [[PHI2]]:_(s32), 128
   CHECK: [[USE_OP:%[0-9]+]]:_(<5 x s32>) = G_AND [[INSERT2]]:_, [[INSERT2]]:_
   )";
 
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
 // FNEG expansion in terms of FSUB
-TEST_F(GISelMITest, LowerFNEG) {
+TEST_F(AArch64GISelMITest, LowerFNEG) {
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_FSUB).legalFor({s64});
   });
 
TEST_F(AArch64GISelMITest, LowerFNEG) {
   CHECK: [[CONST1:%[0-9]+]]:_(s64) = G_FCONSTANT double -0.000000e+00
   CHECK: [[FSUB1:%[0-9]+]]:_(s64) = ninf G_FSUB [[CONST1]]:_, %0:_
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, LowerMinMax) {
+TEST_F(AArch64GISelMITest, LowerMinMax) {
   if (!TM)
     return;
 
   LLT s64 = LLT::scalar(64);
   LLT v2s32 = LLT::vector(2, 32);
 
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder({G_SMIN, G_SMAX, G_UMIN, G_UMAX})
TEST_F(AArch64GISelMITest, LowerMinMax) {
 
   CHECK: [[VCMP3:%[0-9]+]]:_(<2 x s1>) = G_ICMP intpred(ugt), [[VEC0]]:_(<2 x s32>), [[VEC1]]:_
   CHECK: [[UMAXV:%[0-9]+]]:_(<2 x s32>) = G_SELECT [[VCMP3]]:_(<2 x s1>), [[VEC0]]:_, [[VEC1]]:_
   )";
 
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, WidenScalarBuildVector) {
+TEST_F(AArch64GISelMITest, WidenScalarBuildVector) {
   if (!TM)
     return;
 
   LLT S32 = LLT::scalar(32);
   LLT S16 = LLT::scalar(16);
   LLT V2S16 = LLT::vector(2, S16);
   LLT V2S32 = LLT::vector(2, S32);
 
TEST_F(AArch64GISelMITest, WidenScalarBuildVector) {
   CHECK-NEXT: [[EXT_K1_1:%[0-9]+]]:_(s32) = G_ANYEXT [[K1]]
 
   CHECK-NEXT: [[BV1:%[0-9]+]]:_(<2 x s16>) = G_BUILD_VECTOR_TRUNC [[EXT_K0_1]]:_(s32), [[EXT_K1_1]]:_(s32)
   )";
 
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, LowerMergeValues) {
+TEST_F(AArch64GISelMITest, LowerMergeValues) {
   if (!TM)
     return;
 
   const LLT S32 = LLT::scalar(32);
   const LLT S24 = LLT::scalar(24);
   const LLT S21 = LLT::scalar(21);
   const LLT S16 = LLT::scalar(16);
   const LLT S9 = LLT::scalar(9);
TEST_F(AArch64GISelMITest, LowerMergeValues) {
   [[SHL:%[0-9]+]]:_(s32) = G_SHL [[ZEXT_K16]]:_, [[K16]]:_(s32)
   [[OR:%[0-9]+]]:_(s32) = G_OR [[ZEXT_K16]]:_, [[SHL]]:_
   (s16) = G_TRUNC [[OR]]:_(s32)
   )";
 
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, WidenScalarMergeValuesPointer) {
+TEST_F(AArch64GISelMITest, WidenScalarMergeValuesPointer) {
   if (!TM)
     return;
 
   DefineLegalizerInfo(A, {});
 
   AInfo Info(MF->getSubtarget());
   DummyGISelObserver Observer;
   LegalizerHelper Helper(*MF, Info, Observer, B);
TEST_F(AArch64GISelMITest, WidenScalarMergeValuesPointer) {
    CHECK: [[SHL:%[0-9]+]]:_(s64) = G_SHL [[ZEXT_TRUNC1]]:_, [[SHIFT_AMT]]
    CHECK: [[OR:%[0-9]+]]:_(s64) = G_OR [[ZEXT_TRUNC0]]:_, [[SHL]]
    CHECK: [[INTTOPTR:%[0-9]+]]:_(p0) = G_INTTOPTR [[OR]]:_(s64)
   )";
 
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, WidenSEXTINREG) {
+TEST_F(AArch64GISelMITest, WidenSEXTINREG) {
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_SEXT_INREG).legalForTypeWithAnyImm({s64});
   });
   // Build Instr
TEST_F(AArch64GISelMITest, WidenSEXTINREG) {
   CHECK: [[T2:%[0-9]+]]:_(s64) = G_SEXT_INREG [[T1]]:_, 8
   CHECK: [[T3:%[0-9]+]]:_(s32) = G_TRUNC [[T2]]:_(s64)
   )";
 
   // Check
   ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr));
 }
 
-TEST_F(GISelMITest, NarrowSEXTINREG) {
+TEST_F(AArch64GISelMITest, NarrowSEXTINREG) {
   if (!TM)
     return;
 
   // Declare your legalization info, these aren't actually relevant to the test.
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_SEXT_INREG).legalForTypeWithAnyImm({s64});
   });
   // Build Instr
TEST_F(AArch64GISelMITest, NarrowSEXTINREG) {
   CHECK: [[T2:%[0-9]+]]:_(s10) = G_SEXT_INREG [[T1]]:_, 8
   CHECK: [[T3:%[0-9]+]]:_(s16) = G_SEXT [[T2]]:_(s10)
   )";
 
   // Check
   ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr));
 }
 
-TEST_F(GISelMITest, NarrowSEXTINREG2) {
+TEST_F(AArch64GISelMITest, NarrowSEXTINREG2) {
   if (!TM)
     return;
 
   // Declare your legalization info, these aren't actually relevant to the test.
   DefineLegalizerInfo(
       A, { getActionDefinitionsBuilder(G_SEXT_INREG).legalForTypeWithAnyImm({s64}); });
   // Build Instr
   auto MIB = B.buildInstr(
TEST_F(AArch64GISelMITest, NarrowSEXTINREG2) {
   CHECK: [[T6:%[0-9]+]]:_(s8) = G_ASHR [[T5]]:_, [[CST2]]:_
   CHECK: [[T7:%[0-9]+]]:_(s32) = G_MERGE_VALUES [[T1]]:_(s8), [[T5]]:_(s8), [[T6]]:_(s8), [[T6]]:_(s8)
   )";
 
   // Check
   ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr));
 }
 
-TEST_F(GISelMITest, LowerSEXTINREG) {
+TEST_F(AArch64GISelMITest, LowerSEXTINREG) {
   if (!TM)
     return;
 
   // Declare your legalization info, these aren't actually relevant to the test.
   DefineLegalizerInfo(
       A, { getActionDefinitionsBuilder(G_SEXT_INREG).legalForTypeWithAnyImm({s64}); });
   // Build Instr
   auto MIB = B.buildInstr(
TEST_F(AArch64GISelMITest, LowerSEXTINREG) {
   CHECK: [[T2:%[0-9]+]]:_(s32) = G_SHL [[T1]]:_, [[CST]]:_
   CHECK: [[T3:%[0-9]+]]:_(s32) = G_ASHR [[T2]]:_, [[CST]]:_
   )";
 
   // Check
   ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr));
 }
 
-TEST_F(GISelMITest, LibcallFPExt) {
+TEST_F(AArch64GISelMITest, LibcallFPExt) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_FPEXT).libcallFor({{s32, s16}, {s128, s64}});
   });
TEST_F(AArch64GISelMITest, LibcallFPExt) {
   CHECK: $d0 = COPY
   CHECK: BL &__extenddftf2
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, LibcallFPTrunc) {
+TEST_F(AArch64GISelMITest, LibcallFPTrunc) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_FPTRUNC).libcallFor({{s16, s32}, {s64, s128}});
   });
TEST_F(AArch64GISelMITest, LibcallFPTrunc) {
   CHECK: $q0 = COPY
   CHECK: BL &__trunctfdf2
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, LibcallSimple) {
+TEST_F(AArch64GISelMITest, LibcallSimple) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_FADD).libcallFor({s16});
   });
 
   LLT S16{LLT::scalar(16)};
   auto MIBTrunc = B.buildTrunc(S16, Copies[0]);
   auto MIBFADD =
       B.buildInstr(TargetOpcode::G_FADD, {S16}, {MIBTrunc, MIBTrunc});
 
   AInfo Info(MF->getSubtarget());
   DummyGISelObserver Observer;
   LegalizerHelper Helper(*MF, Info, Observer, B);
   // Make sure we do not crash anymore
   EXPECT_EQ(LegalizerHelper::LegalizeResult::UnableToLegalize,
             Helper.libcall(*MIBFADD));
 }
 
-TEST_F(GISelMITest, LibcallSRem) {
+TEST_F(AArch64GISelMITest, LibcallSRem) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_SREM).libcallFor({s32, s64, s128});
   });
TEST_F(AArch64GISelMITest, LibcallSRem) {
   CHECK: $x3 = COPY [[UV3]]
   CHECK: BL &__modti3
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, LibcallURem) {
+TEST_F(AArch64GISelMITest, LibcallURem) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_UREM).libcallFor({s32, s64, s128});
   });
TEST_F(AArch64GISelMITest, LibcallURem) {
   CHECK: $x3 = COPY [[UV3]]
   CHECK: BL &__umodti3
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, LibcallCtlzZeroUndef) {
+TEST_F(AArch64GISelMITest, LibcallCtlzZeroUndef) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_CTLZ_ZERO_UNDEF)
         .libcallFor({{s32, s32}, {s64, s64}, {s128, s128}});
TEST_F(AArch64GISelMITest, LibcallCtlzZeroUndef) {
   CHECK: $x1 = COPY [[UV1]]
   CHECK: BL &__clzti2
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, LibcallFAdd) {
+TEST_F(AArch64GISelMITest, LibcallFAdd) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_FADD).libcallFor({s32, s64, s128});
   });
TEST_F(AArch64GISelMITest, LibcallFAdd) {
   CHECK: $q1 = COPY [[ANYEXT]]
   CHECK: BL &__addtf3
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, LibcallFSub) {
+TEST_F(AArch64GISelMITest, LibcallFSub) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_FSUB).libcallFor({s32, s64, s128});
   });
TEST_F(AArch64GISelMITest, LibcallFSub) {
   CHECK: $q1 = COPY [[ANYEXT]]
   CHECK: BL &__subtf3
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, LibcallFMul) {
+TEST_F(AArch64GISelMITest, LibcallFMul) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_FMUL).libcallFor({s32, s64, s128});
   });
TEST_F(AArch64GISelMITest, LibcallFMul) {
   CHECK: $q1 = COPY [[ANYEXT]]
   CHECK: BL &__multf3
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, LibcallFDiv) {
+TEST_F(AArch64GISelMITest, LibcallFDiv) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_FDIV).libcallFor({s32, s64, s128});
   });
TEST_F(AArch64GISelMITest, LibcallFDiv) {
   CHECK: $q1 = COPY [[ANYEXT]]
   CHECK: BL &__divtf3
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, LibcallFExp) {
+TEST_F(AArch64GISelMITest, LibcallFExp) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_FEXP).libcallFor({s32, s64, s128});
   });
TEST_F(AArch64GISelMITest, LibcallFExp) {
   CHECK: $q0 = COPY [[ANYEXT]]
   CHECK: BL &expl
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, LibcallFExp2) {
+TEST_F(AArch64GISelMITest, LibcallFExp2) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_FEXP2).libcallFor({s32, s64, s128});
   });
TEST_F(AArch64GISelMITest, LibcallFExp2) {
   CHECK: $q0 = COPY [[ANYEXT]]
   CHECK: BL &exp2l
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, LibcallFRem) {
+TEST_F(AArch64GISelMITest, LibcallFRem) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_FREM).libcallFor({s32, s64, s128});
   });
TEST_F(AArch64GISelMITest, LibcallFRem) {
   CHECK: $q0 = COPY [[ANYEXT]]
   CHECK: BL &fmodl
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, LibcallFPow) {
+TEST_F(AArch64GISelMITest, LibcallFPow) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_FPOW).libcallFor({s32, s64, s128});
   });
TEST_F(AArch64GISelMITest, LibcallFPow) {
   CHECK: $q0 = COPY [[ANYEXT]]
   CHECK: BL &powl
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, LibcallFMa) {
+TEST_F(AArch64GISelMITest, LibcallFMa) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_FMA).libcallFor({s32, s64, s128});
   });
TEST_F(AArch64GISelMITest, LibcallFMa) {
   CHECK: $q0 = COPY [[ANYEXT]]
   CHECK: BL &fmal
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, LibcallFCeil) {
+TEST_F(AArch64GISelMITest, LibcallFCeil) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_FCEIL).libcallFor({s32, s64, s128});
   });
TEST_F(AArch64GISelMITest, LibcallFCeil) {
   CHECK: $q0 = COPY [[ANYEXT]]
   CHECK: BL &ceill
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, LibcallFFloor) {
+TEST_F(AArch64GISelMITest, LibcallFFloor) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_FFLOOR).libcallFor({s32, s64, s128});
   });
TEST_F(AArch64GISelMITest, LibcallFFloor) {
   CHECK: $q0 = COPY [[ANYEXT]]
   CHECK: BL &floorl
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, LibcallFMinNum) {
+TEST_F(AArch64GISelMITest, LibcallFMinNum) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_FMINNUM).libcallFor({s32, s64, s128});
   });
TEST_F(AArch64GISelMITest, LibcallFMinNum) {
   CHECK: $q1 = COPY [[ANYEXT]]
   CHECK: BL &fminl
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, LibcallFMaxNum) {
+TEST_F(AArch64GISelMITest, LibcallFMaxNum) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_FMAXNUM).libcallFor({s32, s64, s128});
   });
TEST_F(AArch64GISelMITest, LibcallFMaxNum) {
   CHECK: $q1 = COPY [[ANYEXT]]
   CHECK: BL &fmaxl
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, LibcallFSqrt) {
+TEST_F(AArch64GISelMITest, LibcallFSqrt) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_FSQRT).libcallFor({s32, s64, s128});
   });
TEST_F(AArch64GISelMITest, LibcallFSqrt) {
   CHECK: $q0 = COPY [[ANYEXT]]
   CHECK: BL &sqrtl
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, LibcallFRint) {
+TEST_F(AArch64GISelMITest, LibcallFRint) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_FRINT).libcallFor({s32, s64, s128});
   });
TEST_F(AArch64GISelMITest, LibcallFRint) {
   CHECK: $q0 = COPY [[ANYEXT]]
   CHECK: BL &rintl
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, LibcallFNearbyInt) {
+TEST_F(AArch64GISelMITest, LibcallFNearbyInt) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_FNEARBYINT).libcallFor({s32, s64, s128});
   });
TEST_F(AArch64GISelMITest, LibcallFNearbyInt) {
   CHECK: $q0 = COPY [[ANYEXT]]
   CHECK: BL &nearbyintl
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, NarrowScalarExtract) {
+TEST_F(AArch64GISelMITest, NarrowScalarExtract) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {
     getActionDefinitionsBuilder(G_UNMERGE_VALUES).legalFor({{s32, s64}});
     getActionDefinitionsBuilder(G_EXTRACT).legalFor({{s16, s32}});
TEST_F(AArch64GISelMITest, NarrowScalarExtract) {
   CHECK: [[EXTR:%[0-9]+]]:_(s16) = G_EXTRACT [[UV3]]:_(s32), 0
   CHECK: [[COPY:%[0-9]+]]:_(s16) = COPY [[EXTR]]
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, LowerInsert) {
+TEST_F(AArch64GISelMITest, LowerInsert) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, { getActionDefinitionsBuilder(G_INSERT).lower(); });
 
   LLT S32{LLT::scalar(32)};
TEST_F(AArch64GISelMITest, LowerInsert) {
   CHECK: [[BITCAST:%[0-9]+]]:_(<2 x s32>) = G_BITCAST [[OR]]
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
 // Test lowering of G_FFLOOR
-TEST_F(GISelMITest, LowerFFloor) {
+TEST_F(AArch64GISelMITest, LowerFFloor) {
   setUp();
   if (!TM)
     return;
 
   // Declare your legalization info
   DefineLegalizerInfo(A, {});
   // Build Instr
   auto Floor = B.buildFFloor(LLT::scalar(64), Copies[0], MachineInstr::MIFlag::FmNoInfs);
TEST_F(AArch64GISelMITest, LowerFFloor) {
   = ninf G_FADD [[TRUNC]]:_, [[ITOFP]]:_
   )";
 
   // Check
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
 // Test lowering of G_BSWAP
-TEST_F(GISelMITest, LowerBSWAP) {
+TEST_F(AArch64GISelMITest, LowerBSWAP) {
   setUp();
   if (!TM)
     return;
 
   DefineLegalizerInfo(A, {});
 
   // Make sure vector lowering doesn't assert.
   auto Cast = B.buildBitcast(LLT::vector(2, 32), Copies[0]);

llvm/unittests/CodeGen/GlobalISel/LegalizerTest.cpp

DefineLegalizerInfo(ALegalizer, {
   getActionDefinitionsBuilder(G_ZEXT).legalFor({{s32, s16}});
   getActionDefinitionsBuilder(G_SEXT).legalFor({{s32, s16}});
   getActionDefinitionsBuilder(G_AND).legalFor({s32});
   getActionDefinitionsBuilder(G_SEXT_INREG).lower();
   getActionDefinitionsBuilder(G_ASHR).legalFor({{s32, s32}});
   getActionDefinitionsBuilder(G_SHL).legalFor({{s32, s32}});
 })
 
-TEST_F(GISelMITest, BasicLegalizerTest) {
+TEST_F(AArch64GISelMITest, BasicLegalizerTest) {
   StringRef MIRString = R"(
     %vptr:_(p0) = COPY $x4
     %v:_(<2 x s8>) = G_LOAD %vptr:_(p0) :: (load 2, align 1)
     $h4 = COPY %v:_(<2 x s8>)
   )";
   setUp(MIRString.rtrim(' '));
   if (!TM)
     return;
TEST_F(AArch64GISelMITest, BasicLegalizerTest) {
   )";
 
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckString)) << *MF;
 }
 
 // Making sure the legalization finishes successfully w/o failure to combine
 // away all the legalization artifacts regardless of the order of their
 // creation.
-TEST_F(GISelMITest, UnorderedArtifactCombiningTest) {
+TEST_F(AArch64GISelMITest, UnorderedArtifactCombiningTest) {
   StringRef MIRString = R"(
     %vptr:_(p0) = COPY $x4
     %v:_(<2 x s8>) = G_LOAD %vptr:_(p0) :: (load 2, align 1)
     %v0:_(s8), %v1:_(s8) = G_UNMERGE_VALUES %v:_(<2 x s8>)
     %v0_ext:_(s16) = G_ANYEXT %v0:_(s8)
     $h4 = COPY %v0_ext:_(s16)
   )";
   setUp(MIRString.rtrim(' '));
StringRef CheckString = R"(
     CHECK-NEXT: [[LOAD_0:%[0-9]+]]:_(s16) = G_LOAD %vptr:_(p0) :: (load 1)
     CHECK:      %v0_ext:_(s16) = COPY [[LOAD_0]]:_(s16)
     CHECK-NEXT: $h4 = COPY %v0_ext:_(s16)
   )";
 
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckString)) << *MF;
 }
 
-TEST_F(GISelMITest, UnorderedArtifactCombiningManyCopiesTest) {
+TEST_F(AArch64GISelMITest, UnorderedArtifactCombiningManyCopiesTest) {
   StringRef MIRString = R"(
     %vptr:_(p0) = COPY $x4
     %v:_(<2 x s8>) = G_LOAD %vptr:_(p0) :: (load 2, align 1)
     %vc0:_(<2 x s8>) = COPY %v:_(<2 x s8>)
     %vc1:_(<2 x s8>) = COPY %v:_(<2 x s8>)
     %vc00:_(s8), %vc01:_(s8) = G_UNMERGE_VALUES %vc0:_(<2 x s8>)
     %vc10:_(s8), %vc11:_(s8) = G_UNMERGE_VALUES %vc1:_(<2 x s8>)
     %v0t:_(s8) = COPY %vc00:_(s8)

llvm/unittests/CodeGen/GlobalISel/MachineIRBuilderTest.cpp

 //===- MachineIRBuilderTest.cpp -------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "GISelMITest.h"
 #include "llvm/CodeGen/GlobalISel/MachineIRBuilder.h"
 
-TEST_F(GISelMITest, TestBuildConstantFConstant) {
+TEST_F(AArch64GISelMITest, TestBuildConstantFConstant) {
   setUp();
   if (!TM)
     return;
 
   B.buildConstant(LLT::scalar(32), 42);
   B.buildFConstant(LLT::scalar(32), 1.0);
 
   B.buildConstant(LLT::vector(2, 32), 99);
TEST_F(AArch64GISelMITest, TestBuildConstantFConstant) {
   CHECK: [[FCONST1:%[0-9]+]]:_(s32) = G_FCONSTANT float 2.000000e+00
   CHECK: [[VEC1:%[0-9]+]]:_(<2 x s32>) = G_BUILD_VECTOR [[FCONST1]]:_(s32), [[FCONST1]]:_(s32)
   CHECK: [[FCONST2:%[0-9]+]]:_(s64) = G_FCONSTANT double 4.000000e+00
   )";
 
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-
 #ifdef GTEST_HAS_DEATH_TEST
 #ifndef NDEBUG
 
-TEST_F(GISelMITest, TestBuildConstantFConstantDeath) {
+TEST_F(AArch64GISelMITest, TestBuildConstantFConstantDeath) {
   setUp();
   if (!TM)
     return;
 
   LLVMContext &Ctx = MF->getFunction().getContext();
   APInt APV32(32, 12345);
 
   // Test APInt version breaks
EXPECT_DEATH(B.buildFConstant(LLT::scalar(16), *CF),
                "creating fconstant with the wrong size");
   EXPECT_DEATH(B.buildFConstant(LLT::vector(2, 16), *CF),
                "creating fconstant with the wrong size");
 }
 
 #endif
 #endif
 
-TEST_F(GISelMITest, DstOpSrcOp) {
+TEST_F(AArch64GISelMITest, DstOpSrcOp) {
   setUp();
   if (!TM)
     return;
 
   SmallVector<Register, 4> Copies;
   collectCopies(Copies, MF);
 
   LLT s64 = LLT::scalar(64);
TEST_F(AArch64GISelMITest, DstOpSrcOp) {
   ; CHECK: [[COPY1:%[0-9]+]]:_(s64) = COPY $x1
   ; CHECK: [[ADD:%[0-9]+]]:_(s64) = G_ADD [[COPY0]]:_, [[COPY1]]:_
   ; CHECK: [[ADD]]:_(s64) = G_ADD [[COPY0]]:_, [[COPY1]]:_
   )";
 
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, BuildUnmerge) {
+TEST_F(AArch64GISelMITest, BuildUnmerge) {
   setUp();
   if (!TM)
     return;
 
   SmallVector<Register, 4> Copies;
   collectCopies(Copies, MF);
   B.buildUnmerge(LLT::scalar(32), Copies[0]);
   B.buildUnmerge(LLT::scalar(16), Copies[1]);
 
   auto CheckStr = R"(
   ; CHECK: [[COPY0:%[0-9]+]]:_(s64) = COPY $x0
   ; CHECK: [[COPY1:%[0-9]+]]:_(s64) = COPY $x1
   ; CHECK: [[UNMERGE32_0:%[0-9]+]]:_(s32), [[UNMERGE32_1:%[0-9]+]]:_(s32) = G_UNMERGE_VALUES [[COPY0]]
   ; CHECK: [[UNMERGE16_0:%[0-9]+]]:_(s16), [[UNMERGE16_1:%[0-9]+]]:_(s16), [[UNMERGE16_2:%[0-9]+]]:_(s16), [[UNMERGE16_3:%[0-9]+]]:_(s16) = G_UNMERGE_VALUES [[COPY1]]
 
   )";
 
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, TestBuildFPInsts) {
+TEST_F(AArch64GISelMITest, TestBuildFPInsts) {
   setUp();
   if (!TM)
     return;
 
   SmallVector<Register, 4> Copies;
   collectCopies(Copies, MF);
 
   LLT S64 = LLT::scalar(64);
TEST_F(AArch64GISelMITest, TestBuildFPInsts) {
   ; CHECK: [[FNEG:%[0-9]+]]:_(s64) = G_FNEG [[COPY0]]:_
   ; CHECK: [[FABS:%[0-9]+]]:_(s64) = G_FABS [[COPY0]]:_
   ; CHECK: [[FCOPYSIGN:%[0-9]+]]:_(s64) = G_FCOPYSIGN [[COPY0]]:_, [[COPY1]]:_
   )";
 
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, BuildIntrinsic) {
+TEST_F(AArch64GISelMITest, BuildIntrinsic) {
   setUp();
   if (!TM)
     return;
 
   LLT S64 = LLT::scalar(64);
   SmallVector<Register, 4> Copies;
   collectCopies(Copies, MF);
 
TEST_F(AArch64GISelMITest, BuildIntrinsic) {
   ; CHECK: [[COPY1:%[0-9]+]]:_(s64) = COPY $x1
   ; CHECK: [[SQRT0:%[0-9]+]]:_(s64) = G_INTRINSIC intrinsic(@llvm.sqrt), [[COPY0]]:_
   ; CHECK: [[SQRT1:%[0-9]+]]:_(s64) = G_INTRINSIC intrinsic(@llvm.sqrt), [[COPY1]]:_
   )";
 
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, BuildXor) {
+TEST_F(AArch64GISelMITest, BuildXor) {
   setUp();
   if (!TM)
     return;
 
   LLT S64 = LLT::scalar(64);
   LLT S128 = LLT::scalar(128);
   SmallVector<Register, 4> Copies;
   collectCopies(Copies, MF);
TEST_F(AArch64GISelMITest, BuildXor) {
   ; CHECK: [[MERGE:%[0-9]+]]:_(s128) = G_MERGE_VALUES [[COPY0]]:_(s64), [[COPY1]]:_(s64)
   ; CHECK: [[NEGONE128:%[0-9]+]]:_(s128) = G_CONSTANT i128 -1
   ; CHECK: [[XOR2:%[0-9]+]]:_(s128) = G_XOR [[MERGE]]:_, [[NEGONE128]]:_
   )";
 
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, BuildBitCounts) {
+TEST_F(AArch64GISelMITest, BuildBitCounts) {
   setUp();
   if (!TM)
     return;
 
   LLT S32 = LLT::scalar(32);
   SmallVector<Register, 4> Copies;
   collectCopies(Copies, MF);
 
TEST_F(AArch64GISelMITest, BuildBitCounts) {
   ; CHECK: [[CTLZ_UNDEF0:%[0-9]+]]:_(s32) = G_CTLZ_ZERO_UNDEF [[COPY1]]:_
   ; CHECK: [[CTTZ:%[0-9]+]]:_(s32) = G_CTTZ [[COPY0]]:_
   ; CHECK: [[CTTZ_UNDEF0:%[0-9]+]]:_(s32) = G_CTTZ_ZERO_UNDEF [[COPY1]]:_
   )";
 
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, BuildCasts) {
+TEST_F(AArch64GISelMITest, BuildCasts) {
   setUp();
   if (!TM)
     return;
 
   LLT S32 = LLT::scalar(32);
   SmallVector<Register, 4> Copies;
   collectCopies(Copies, MF);
 
   B.buildUITOFP(S32, Copies[0]);
   B.buildSITOFP(S32, Copies[0]);
   B.buildFPTOUI(S32, Copies[0]);
   B.buildFPTOSI(S32, Copies[0]);
 
   auto CheckStr = R"(
   ; CHECK: [[COPY0:%[0-9]+]]:_(s64) = COPY $x0
   ; CHECK: [[UITOFP:%[0-9]+]]:_(s32) = G_UITOFP [[COPY0]]:_
   ; CHECK: [[SITOFP:%[0-9]+]]:_(s32) = G_SITOFP [[COPY0]]:_
   ; CHECK: [[FPTOUI:%[0-9]+]]:_(s32) = G_FPTOUI [[COPY0]]:_
   ; CHECK: [[FPTOSI:%[0-9]+]]:_(s32) = G_FPTOSI [[COPY0]]:_
   )";
 
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, BuildMinMax) {
+TEST_F(AArch64GISelMITest, BuildMinMax) {
   setUp();
   if (!TM)
     return;
 
   LLT S64 = LLT::scalar(64);
   SmallVector<Register, 4> Copies;
   collectCopies(Copies, MF);
 
TEST_F(AArch64GISelMITest, BuildMinMax) {
   ; CHECK: [[SMAX0:%[0-9]+]]:_(s64) = G_SMAX [[COPY0]]:_, [[COPY1]]:_
   ; CHECK: [[UMIN0:%[0-9]+]]:_(s64) = G_UMIN [[COPY0]]:_, [[COPY1]]:_
   ; CHECK: [[UMAX0:%[0-9]+]]:_(s64) = G_UMAX [[COPY0]]:_, [[COPY1]]:_
   )";
 
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, BuildAtomicRMW) {
+TEST_F(AArch64GISelMITest, BuildAtomicRMW) {
   setUp();
   if (!TM)
     return;
 
   LLT S64 = LLT::scalar(64);
   LLT P0 = LLT::pointer(0, 64);
   SmallVector<Register, 4> Copies;
   collectCopies(Copies, MF);
TEST_F(AArch64GISelMITest, BuildAtomicRMW) {
   ; CHECK: [[PTR:%[0-9]+]]:_(p0) = G_IMPLICIT_DEF
   ; CHECK: [[FADD:%[0-9]+]]:_(s64) = G_ATOMICRMW_FADD [[PTR]]:_(p0), [[COPY0]]:_ :: (load store unordered 8)
   ; CHECK: [[FSUB:%[0-9]+]]:_(s64) = G_ATOMICRMW_FSUB [[PTR]]:_(p0), [[COPY0]]:_ :: (load store unordered 8)
   )";
 
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, BuildMerge) {
+TEST_F(AArch64GISelMITest, BuildMerge) {
   setUp();
   if (!TM)
     return;
 
   LLT S32 = LLT::scalar(32);
   Register RegC0 = B.buildConstant(S32, 0).getReg(0);
   Register RegC1 = B.buildConstant(S32, 1).getReg(0);
   Register RegC2 = B.buildConstant(S32, 2).getReg(0);
TEST_F(AArch64GISelMITest, BuildMerge) {
   ; CHECK: [[LOW2x32:%[0-9]+]]:_(<2 x s32>) = G_BUILD_VECTOR [[C0]]:_(s32), [[C1]]:_(s32)
   ; CHECK: [[HIGH2x32:%[0-9]+]]:_(<2 x s32>) = G_BUILD_VECTOR [[C2]]:_(s32), [[C3]]:_(s32)
   ; CHECK: {{%[0-9]+}}:_(<4 x s32>) = G_CONCAT_VECTORS [[LOW2x32]]:_(<2 x s32>), [[HIGH2x32]]:_(<2 x s32>)
   )";
 
   EXPECT_TRUE(CheckMachineFunction(*MF, CheckStr)) << *MF;
 }
 
-TEST_F(GISelMITest, BuildAddoSubo) {
+TEST_F(AArch64GISelMITest, BuildAddoSubo) {
   setUp();
   if (!TM)
     return;
 
   LLT S1 = LLT::scalar(1);
   LLT S64 = LLT::scalar(64);
   SmallVector<Register, 4> Copies;
   collectCopies(Copies, MF);

llvm/unittests/CodeGen/GlobalISel/PatternMatchTest.cpp

 #include "llvm/Target/TargetOptions.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace MIPatternMatch;
 
 namespace {
 
-TEST_F(GISelMITest, MatchIntConstant) {
+TEST_F(AArch64GISelMITest, MatchIntConstant) {
   setUp();
   if (!TM)
     return;
   auto MIBCst = B.buildConstant(LLT::scalar(64), 42);
   int64_t Cst;
   bool match = mi_match(MIBCst.getReg(0), *MRI, m_ICst(Cst));
   EXPECT_TRUE(match);
   EXPECT_EQ(Cst, 42);
 }
 
-TEST_F(GISelMITest, MatchBinaryOp) {
+TEST_F(AArch64GISelMITest, MatchBinaryOp) {
   setUp();
   if (!TM)
     return;
   LLT s32 = LLT::scalar(32);
   LLT s64 = LLT::scalar(64);
   auto MIBAdd = B.buildAdd(s64, Copies[0], Copies[1]);
   // Test case for no bind.
   bool match =
TEST_F(AArch64GISelMITest, MatchBinaryOp) {
   auto LShr = B.buildLShr(s64, Copies[0], TruncCopy1);
   match = mi_match(LShr.getReg(0), *MRI,
                    m_GLShr(m_Reg(Src0), m_Reg(Src1)));
   EXPECT_TRUE(match);
   EXPECT_EQ(Src0, Copies[0]);
   EXPECT_EQ(Src1, TruncCopy1.getReg(0));
 }
 
-TEST_F(GISelMITest, MatchICmp) {
+TEST_F(AArch64GISelMITest, MatchICmp) {
   setUp();
   if (!TM)
     return;
 
   const LLT s1 = LLT::scalar(1);
   auto CmpEq = B.buildICmp(CmpInst::ICMP_EQ, s1, Copies[0], Copies[1]);
 
   // Check match any predicate.
   bool match =
       mi_match(CmpEq.getReg(0), *MRI, m_GICmp(m_Pred(), m_Reg(), m_Reg()));
   EXPECT_TRUE(match);
 
   // Check we get the predicate and registers.
   CmpInst::Predicate Pred;
   Register Reg0;
   Register Reg1;
   match = mi_match(CmpEq.getReg(0), *MRI,
                    m_GICmp(m_Pred(Pred), m_Reg(Reg0), m_Reg(Reg1)));
   EXPECT_TRUE(match);
   EXPECT_EQ(CmpInst::ICMP_EQ, Pred);
   EXPECT_EQ(Copies[0], Reg0);
   EXPECT_EQ(Copies[1], Reg1);
 }
 
-TEST_F(GISelMITest, MatchFCmp) {
+TEST_F(AArch64GISelMITest, MatchFCmp) {
   setUp();
   if (!TM)
     return;
 
   const LLT s1 = LLT::scalar(1);
   auto CmpEq = B.buildFCmp(CmpInst::FCMP_OEQ, s1, Copies[0], Copies[1]);
 
   // Check match any predicate.
   bool match =
       mi_match(CmpEq.getReg(0), *MRI, m_GFCmp(m_Pred(), m_Reg(), m_Reg()));
   EXPECT_TRUE(match);
 
   // Check we get the predicate and registers.
   CmpInst::Predicate Pred;
   Register Reg0;
   Register Reg1;
   match = mi_match(CmpEq.getReg(0), *MRI,
                    m_GFCmp(m_Pred(Pred), m_Reg(Reg0), m_Reg(Reg1)));
   EXPECT_TRUE(match);
   EXPECT_EQ(CmpInst::FCMP_OEQ, Pred);
   EXPECT_EQ(Copies[0], Reg0);
   EXPECT_EQ(Copies[1], Reg1);
 }
 
-TEST_F(GISelMITest, MatchFPUnaryOp) {
+TEST_F(AArch64GISelMITest, MatchFPUnaryOp) {
   setUp();
   if (!TM)
     return;
 
   // Truncate s64 to s32.
   LLT s32 = LLT::scalar(32);
   auto Copy0s32 = B.buildFPTrunc(s32, Copies[0]);
 
TEST_F(AArch64GISelMITest, MatchFPUnaryOp) {
   bool Ignored;
   APFloat APF16(.5);
   APF16.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven, &Ignored);
   auto CFP16 = ConstantFP::get(Context, APF16);
   EXPECT_EQ(TmpFP16, CFP16);
   EXPECT_NE(TmpFP16, TmpFP);
 }
 
-TEST_F(GISelMITest, MatchExtendsTrunc) {
+TEST_F(AArch64GISelMITest, MatchExtendsTrunc) {
   setUp();
   if (!TM)
     return;
 
   LLT s64 = LLT::scalar(64);
   LLT s32 = LLT::scalar(32);
 
   auto MIBTrunc = B.buildTrunc(s32, Copies[0]);
TEST_F(AArch64GISelMITest, MatchExtendsTrunc) {
   EXPECT_EQ(Src0, Copies[0]);
 
   match = mi_match(MIBZExt.getReg(0), *MRI,
                    m_GZExt(m_GTrunc(m_Reg(Src0))));
   EXPECT_TRUE(match);
   EXPECT_EQ(Src0, Copies[0]);
 }
 
-TEST_F(GISelMITest, MatchSpecificType) {
+TEST_F(AArch64GISelMITest, MatchSpecificType) {
   setUp();
   if (!TM)
     return;
 
   // Try to match a 64bit add.
   LLT s64 = LLT::scalar(64);
   LLT s32 = LLT::scalar(32);
   auto MIBAdd = B.buildAdd(s64, Copies[0], Copies[1]);
TEST_F(AArch64GISelMITest, MatchSpecificType) {
 
   // match the ptrtoint(inttoptr reg)
   bool match = mi_match(MIBPtrToInt.getReg(0), *MRI,
                         m_GPtrToInt(m_GIntToPtr(m_Reg(Src0))));
   EXPECT_TRUE(match);
   EXPECT_EQ(Src0, Copies[0]);
 }
 
-TEST_F(GISelMITest, MatchCombinators) {
+TEST_F(AArch64GISelMITest, MatchCombinators) {
   setUp();
   if (!TM)
     return;
 
   LLT s64 = LLT::scalar(64);
   LLT s32 = LLT::scalar(32);
   auto MIBAdd = B.buildAdd(s64, Copies[0], Copies[1]);
   Register Src0, Src1;
TEST_F(AArch64GISelMITest, MatchCombinators) {
 
   // Match a case where none of the predicates hold true.
   match = mi_match(
       MIBAdd.getReg(0), *MRI,
       m_any_of(m_SpecificType(LLT::scalar(16)), m_GSub(m_Reg(), m_Reg())));
   EXPECT_FALSE(match);
 }
 
-TEST_F(GISelMITest, MatchMiscellaneous) {
+TEST_F(AArch64GISelMITest, MatchMiscellaneous) {
   setUp();
   if (!TM)
     return;
 
   LLT s64 = LLT::scalar(64);
   auto MIBAdd = B.buildAdd(s64, Copies[0], Copies[1]);
   // Make multiple uses of this add.
   B.buildCast(LLT::pointer(0, 32), MIBAdd);