[llvm-exegesis][NFC] More tests for ExegesisTarget::fillMemoryOperands().

[gchatelet]

Thx!

llvm/trunk/tools/llvm-exegesis/lib/LlvmState.h

 // An object to initialize LLVM and prepare objects needed to run the
 // measurements.
 class LLVMState {
 public:
   // Uses the host triple. If CpuName is empty, uses the host CPU.
   LLVMState(const std::string &CpuName);
 
   LLVMState(const std::string &Triple,
-            const std::string &CpuName); // For tests.
+            const std::string &CpuName,
+            const std::string &Features = ""); // For tests.
 
   const llvm::TargetMachine &getTargetMachine() const { return *TargetMachine; }
   std::unique_ptr<llvm::LLVMTargetMachine> createTargetMachine() const;
 
   const ExegesisTarget &getExegesisTarget() const { return *TheExegesisTarget; }
 
   bool canAssemble(const llvm::MCInst &mc_inst) const;
 

llvm/trunk/tools/llvm-exegesis/lib/LlvmState.cpp

 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetOptions.h"
 
 namespace llvm {
 namespace exegesis {
 
-LLVMState::LLVMState(const std::string &Triple, const std::string &CpuName) {
+LLVMState::LLVMState(const std::string &Triple, const std::string &CpuName,
+                     const std::string &Features) {
   std::string Error;
   const llvm::Target *const TheTarget =
       llvm::TargetRegistry::lookupTarget(Triple, Error);
   assert(TheTarget && "unknown target for host");
   const llvm::TargetOptions Options;
-  TargetMachine.reset(static_cast<llvm::LLVMTargetMachine *>(
-      TheTarget->createTargetMachine(Triple, CpuName, /*Features*/ "", Options,
-                                     llvm::Reloc::Model::Static)));
+  TargetMachine.reset(
+      static_cast<llvm::LLVMTargetMachine *>(TheTarget->createTargetMachine(
+          Triple, CpuName, Features, Options, llvm::Reloc::Model::Static)));
   TheExegesisTarget = ExegesisTarget::lookup(TargetMachine->getTargetTriple());
   if (!TheExegesisTarget) {
     llvm::errs() << "no exegesis target for " << Triple << ", using default\n";
     TheExegesisTarget = &ExegesisTarget::getDefault();
   }
   PfmCounters = &TheExegesisTarget->getPfmCounters(CpuName);
 
   RATC.reset(new RegisterAliasingTrackerCache(
       getRegInfo(), getFunctionReservedRegs(getTargetMachine())));
   IC.reset(new InstructionsCache(getInstrInfo(), getRATC()));
 }
 
 LLVMState::LLVMState(const std::string &CpuName)
     : LLVMState(llvm::sys::getProcessTriple(),
-                CpuName.empty() ? llvm::sys::getHostCPUName().str() : CpuName) {
-}
+                CpuName.empty() ? llvm::sys::getHostCPUName().str() : CpuName,
+                "") {}
 
 std::unique_ptr<llvm::LLVMTargetMachine>
 LLVMState::createTargetMachine() const {
   return std::unique_ptr<llvm::LLVMTargetMachine>(
       static_cast<llvm::LLVMTargetMachine *>(
           TargetMachine->getTarget().createTargetMachine(
               TargetMachine->getTargetTriple().normalize(),
               TargetMachine->getTargetCPU(),

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

return AllOf(
       OpcodeIs(llvm::X86::ADD64ri8),
       ElementsAre(IsReg(llvm::X86::RSP), IsReg(llvm::X86::RSP), IsImm(Size)));
 }
 
 constexpr const char kTriple[] = "x86_64-unknown-linux";
 
 class X86TargetTest : public ::testing::Test {
 protected:
-  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, "core2", Features));
-  }
+  X86TargetTest(const char *Features) : State(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);
+    return State.getExegesisTarget().setRegTo(State.getSubtargetInfo(), Reg,
+                                              Value);
   }
 
-  const llvm::Target *Target_;
-  const ExegesisTarget *const ExegesisTarget_;
-  std::unique_ptr<llvm::MCSubtargetInfo> STI_;
+  LLVMState State;
 };
 
 class Core2TargetTest : public X86TargetTest {
 public:
   Core2TargetTest() : X86TargetTest("") {}
 };
 
 class Core2AvxTargetTest : public X86TargetTest {

 
 TEST_F(Core2TargetTest, SetRegToFP1_32Bits) {
   EXPECT_THAT(
       setRegTo(llvm::X86::FP1, APInt(32, 0x11112222ULL)),
       ElementsAre(IsStackAllocate(10),
                   IsMovValueToStack(llvm::X86::MOV32mi, 0x11112222UL, 0),
                   IsMovValueToStack(llvm::X86::MOV32mi, 0x00000000UL, 4),
                   IsMovValueToStack(llvm::X86::MOV16mi, 0x0000UL, 8),
-                  OpcodeIs(llvm::X86::LD_Fp80m),
-                  IsStackDeallocate(10)));
+                  OpcodeIs(llvm::X86::LD_Fp80m), IsStackDeallocate(10)));
 }
 
 TEST_F(Core2TargetTest, SetRegToFP1_4Bits) {
   EXPECT_THAT(
       setRegTo(llvm::X86::FP1, APInt(4, 0x1ULL)),
       ElementsAre(IsStackAllocate(10),
                   IsMovValueToStack(llvm::X86::MOV32mi, 0x00000001UL, 0),
                   IsMovValueToStack(llvm::X86::MOV32mi, 0x00000000UL, 4),
                   IsMovValueToStack(llvm::X86::MOV16mi, 0x0000UL, 8),
-                  OpcodeIs(llvm::X86::LD_Fp80m),
-                  IsStackDeallocate(10)));
+                  OpcodeIs(llvm::X86::LD_Fp80m), IsStackDeallocate(10)));
+}
+
+TEST_F(Core2Avx512TargetTest, FillMemoryOperands_ADD64rm) {
+  Instruction I(State.getInstrInfo(), State.getRATC(), X86::ADD64rm);
+  InstructionTemplate IT(I);
+  constexpr const int kOffset = 42;
+  State.getExegesisTarget().fillMemoryOperands(IT, X86::RDI, kOffset);
+  // Memory is operands 2-6.
+  EXPECT_THAT(IT.getValueFor(I.Operands[2]), IsReg(X86::RDI));
+  EXPECT_THAT(IT.getValueFor(I.Operands[3]), IsImm(1));
+  EXPECT_THAT(IT.getValueFor(I.Operands[4]), IsReg(0));
+  EXPECT_THAT(IT.getValueFor(I.Operands[5]), IsImm(kOffset));
+  EXPECT_THAT(IT.getValueFor(I.Operands[6]), IsReg(0));
+}
+
+TEST_F(Core2Avx512TargetTest, FillMemoryOperands_VGATHERDPSZ128rm) {
+  Instruction I(State.getInstrInfo(), State.getRATC(), X86::VGATHERDPSZ128rm);
+  InstructionTemplate IT(I);
+  constexpr const int kOffset = 42;
+  State.getExegesisTarget().fillMemoryOperands(IT, X86::RDI, kOffset);
+  // Memory is operands 4-8.
+  EXPECT_THAT(IT.getValueFor(I.Operands[4]), IsReg(X86::RDI));
+  EXPECT_THAT(IT.getValueFor(I.Operands[5]), IsImm(1));
+  EXPECT_THAT(IT.getValueFor(I.Operands[6]), IsReg(0));
+  EXPECT_THAT(IT.getValueFor(I.Operands[7]), IsImm(kOffset));
+  EXPECT_THAT(IT.getValueFor(I.Operands[8]), IsReg(0));
 }
 
 } // namespace
 } // namespace exegesis
 } // namespace llvm