[llvm-exegesis] Fix broken build bots.

llvm/trunk/unittests/tools/llvm-exegesis/AArch64/TargetTest.cpp

 
 using llvm::APInt;
 using llvm::MCInst;
 using testing::Gt;
 using testing::IsEmpty;
 using testing::Not;
 using testing::NotNull;
 
-static const char kTriple[] = "aarch64-unknown-linux";
-static const char kGenericCpu[] = "generic";
-static const char kNoFeatures[] = "";
+constexpr const char kTriple[] = "aarch64-unknown-linux";
 
 class AArch64TargetTest : public ::testing::Test {
 protected:
   AArch64TargetTest()
       : ExegesisTarget_(ExegesisTarget::lookup(llvm::Triple(kTriple))) {
     EXPECT_THAT(ExegesisTarget_, NotNull());
     std::string error;
     Target_ = llvm::TargetRegistry::lookupTarget(kTriple, error);
     EXPECT_THAT(Target_, NotNull());
     STI_.reset(
-        Target_->createMCSubtargetInfo(kTriple, kGenericCpu, kNoFeatures));
+        Target_->createMCSubtargetInfo(kTriple, "generic", /*no features*/ ""));
   }
 
   static void SetUpTestCase() {
     LLVMInitializeAArch64TargetInfo();
     LLVMInitializeAArch64Target();
     LLVMInitializeAArch64TargetMC();
     InitializeAArch64ExegesisTarget();
   }

llvm/trunk/unittests/tools/llvm-exegesis/X86/TargetTest.cpp

 }
 
 Matcher<MCInst> IsStackDeallocate(unsigned Size) {
   return AllOf(
       OpcodeIs(llvm::X86::ADD64ri8),
       ElementsAre(IsReg(llvm::X86::RSP), IsReg(llvm::X86::RSP), IsImm(Size)));
 }
 
-static const char kTriple[] = "x86_64-unknown-linux";
-static const char kFeaturesEmpty[] = "";
-static const char kFeaturesAvx[] = "+avx";
-static const char kFeaturesAvx512VL[] = "+avx512vl";
-static const char kCpuCore2[] = "core2";
+constexpr const char kTriple[] = "x86_64-unknown-linux";
 
-template <const char *CPU, const char *Features>
 class X86TargetTest : public ::testing::Test {
 protected:
-  X86TargetTest()
+  X86TargetTest(const char *Features)
       : ExegesisTarget_(ExegesisTarget::lookup(llvm::Triple(kTriple))) {
     EXPECT_THAT(ExegesisTarget_, NotNull());
     std::string error;
     Target_ = llvm::TargetRegistry::lookupTarget(kTriple, error);
     EXPECT_THAT(Target_, NotNull());
-    STI_.reset(Target_->createMCSubtargetInfo(kTriple, kCpuCore2, Features));
+    STI_.reset(Target_->createMCSubtargetInfo(kTriple, "core2", Features));
   }
 
   static void SetUpTestCase() {
     LLVMInitializeX86TargetInfo();
     LLVMInitializeX86Target();
     LLVMInitializeX86TargetMC();
     InitializeX86ExegesisTarget();
   }
 
   std::vector<MCInst> setRegTo(unsigned Reg, const APInt &Value) {
     return ExegesisTarget_->setRegTo(*STI_, Reg, Value);
   }
 
   const llvm::Target *Target_;
   const ExegesisTarget *const ExegesisTarget_;
   std::unique_ptr<llvm::MCSubtargetInfo> STI_;
 };
 
-using Core2TargetTest = X86TargetTest<kCpuCore2, kFeaturesEmpty>;
-using Core2AvxTargetTest = X86TargetTest<kCpuCore2, kFeaturesAvx>;
-using Core2Avx512TargetTest = X86TargetTest<kCpuCore2, kFeaturesAvx512VL>;
+class Core2TargetTest : public X86TargetTest {
+public:
+  Core2TargetTest() : X86TargetTest("") {}
+};
+
+class Core2AvxTargetTest : public X86TargetTest {
+public:
+  Core2AvxTargetTest() : X86TargetTest("+avx") {}
+};
+
+class Core2Avx512TargetTest : public X86TargetTest {
+public:
+  Core2Avx512TargetTest() : X86TargetTest("+avx512vl") {}
+};
 
 TEST_F(Core2TargetTest, SetFlags) {
   const unsigned Reg = llvm::X86::EFLAGS;
   EXPECT_THAT(
       setRegTo(Reg, APInt(64, 0x1111222233334444ULL)),
       ElementsAre(IsStackAllocate(8),
                   IsMovValueToStack(llvm::X86::MOV32mi, 0x33334444UL, 0),
                   IsMovValueToStack(llvm::X86::MOV32mi, 0x11112222UL, 4),