[llvm-exegesis] Fix support for LEA64_32r.

[courbet]

Summary

Add unit test to show the issue: We must select an *aliasing* output
register, not the exact register.

[gchatelet]

LGTM appart a few typos

llvm/tools/llvm-exegesis/lib/X86/Target.cpp

276

a destination

330

addressing

[courbet]

Thanks

[courbet]

fix typos

llvm/test/tools/llvm-exegesis/X86/latency-LEA64_32r.s

+# RUN: llvm-exegesis -mode=latency -opcode-name=LEA64_32r -repetition-mode=duplicate -max-configs-per-opcode=2 | FileCheck %s
+# RUN: llvm-exegesis -mode=latency -opcode-name=LEA64_32r -repetition-mode=loop -max-configs-per-opcode=2 | FileCheck %s
+
+CHECK:      ---
+CHECK-NEXT: mode: latency
+CHECK-NEXT: key:
+CHECK-NEXT:   instructions:
+CHECK-NEXT:     LEA64_32r
+CHECK-NEXT: config: '0(%[[REG1:[A-Z0-9]+]], %[[REG1]], 1)'
+
+CHECK:      ---
+CHECK-NEXT: mode: latency
+CHECK-NEXT: key:
+CHECK-NEXT:   instructions:
+CHECK-NEXT:     LEA64_32r
+CHECK-NEXT: config: '42(%[[REG2:[A-Z0-9]+]], %[[REG2]], 1)'

llvm/tools/llvm-exegesis/lib/X86/Target.cpp

static void setMemOp(InstructionTemplate &IT, int OpIdx,
   IT.getValueFor(Op) = OpVal;
 }
 
 // Common (latency, uops) code for LEA templates. `GetDestReg` takes the
 // addressing base and index registers and returns the LEA destination register.
 static Expected<std::vector<CodeTemplate>> generateLEATemplatesCommon(
     const Instruction &Instr, const BitVector &ForbiddenRegisters,
     const LLVMState &State, const SnippetGenerator::Options &Opts,
-    std::function<unsigned(unsigned, unsigned)> GetDestReg) {
+    std::function<void(unsigned, unsigned, BitVector &CandidateDestRegs)>
+        RestrictDestRegs) {
   assert(Instr.Operands.size() == 6 && "invalid LEA");
   assert(X86II::getMemoryOperandNo(Instr.Description.TSFlags) == 1 &&
          "invalid LEA");
 
   constexpr const int kDestOp = 0;
   constexpr const int kBaseOp = 1;
   constexpr const int kIndexOp = 3;
   auto PossibleDestRegs =
for (const unsigned IndexReg : PossibleIndexRegs.set_bits()) {
           const int64_t Scale = 1ull << LogScale;
           setMemOp(IT, 1, MCOperand::createReg(BaseReg));
           setMemOp(IT, 2, MCOperand::createImm(Scale));
           setMemOp(IT, 3, MCOperand::createReg(IndexReg));
           setMemOp(IT, 4, MCOperand::createImm(Disp));
           // SegmentReg must be 0 for LEA.
           setMemOp(IT, 5, MCOperand::createReg(0));
 
-          // Output reg is selected by the caller.
-          setMemOp(IT, 0, MCOperand::createReg(GetDestReg(BaseReg, IndexReg)));
+          // Output reg candidates are selected by the caller.
+          auto PossibleDestRegsNow = PossibleDestRegs;
+          RestrictDestRegs(BaseReg, IndexReg, PossibleDestRegsNow);
+          assert(PossibleDestRegsNow.set_bits().begin() !=
+                     PossibleDestRegsNow.set_bits().end() &&
+                 "no remaining registers");
+          setMemOp(
+              IT, 0,
+              MCOperand::createReg(*PossibleDestRegsNow.set_bits().begin()));
 
           CodeTemplate CT;
           CT.Instructions.push_back(std::move(IT));
           CT.Config = formatv("{3}(%{0}, %{1}, {2})", RegInfo.getName(BaseReg),
                               RegInfo.getName(IndexReg), Scale, Disp)
                           .str();
           Result.push_back(std::move(CT));
           if (Result.size() >= Opts.MaxConfigsPerOpcode)

 X86SerialSnippetGenerator::generateCodeTemplates(
     const Instruction &Instr, const BitVector &ForbiddenRegisters) const {
   if (auto E = IsInvalidOpcode(Instr))
     return std::move(E);
 
   // LEA gets special attention.
   const auto Opcode = Instr.Description.getOpcode();
   if (Opcode == X86::LEA64r || Opcode == X86::LEA64_32r) {
-    return generateLEATemplatesCommon(Instr, ForbiddenRegisters, State, Opts,
-                                      [](unsigned BaseReg, unsigned IndexReg) {
-                                        // We just select the same base and
-                                        // output register.
-                                        return BaseReg;
-                                      });
+    return generateLEATemplatesCommon(
+        Instr, ForbiddenRegisters, State, Opts,
+        [this](unsigned BaseReg, unsigned IndexReg,
+               BitVector &CandidateDestRegs) {
+          // We just select a destination register that aliases the base
+          // register.
+          CandidateDestRegs &=
+              State.getRATC().getRegister(BaseReg).aliasedBits();
   }
 
   switch (getX86FPFlags(Instr)) {
   case X86II::NotFP:
     return SerialSnippetGenerator::generateCodeTemplates(Instr,
                                                           ForbiddenRegisters);
   case X86II::ZeroArgFP:
   case X86II::OneArgFP:

 X86ParallelSnippetGenerator::generateCodeTemplates(
     const Instruction &Instr, const BitVector &ForbiddenRegisters) const {
   if (auto E = IsInvalidOpcode(Instr))
     return std::move(E);
 
   // LEA gets special attention.
   const auto Opcode = Instr.Description.getOpcode();
   if (Opcode == X86::LEA64r || Opcode == X86::LEA64_32r) {
-    // Any destination register that is not used for adddressing is fine.
-    auto PossibleDestRegs =
-        Instr.Operands[0].getRegisterAliasing().sourceBits();
-    remove(PossibleDestRegs, ForbiddenRegisters);
     return generateLEATemplatesCommon(
         Instr, ForbiddenRegisters, State, Opts,
-        [this, &PossibleDestRegs](unsigned BaseReg, unsigned IndexReg) {
-          auto PossibleDestRegsNow = PossibleDestRegs;
-          remove(PossibleDestRegsNow,
+        [this](unsigned BaseReg, unsigned IndexReg,
+               BitVector &CandidateDestRegs) {
+          // Any destination register that is not used for addressing is fine.
+          remove(CandidateDestRegs,
                  State.getRATC().getRegister(BaseReg).aliasedBits());
-          remove(PossibleDestRegsNow,
+          remove(CandidateDestRegs,
                  State.getRATC().getRegister(IndexReg).aliasedBits());
-          assert(PossibleDestRegsNow.set_bits().begin() !=
-                     PossibleDestRegsNow.set_bits().end() &&
-                 "no remaining registers");
-          return *PossibleDestRegsNow.set_bits().begin();
         });
   }
 
   switch (getX86FPFlags(Instr)) {
   case X86II::NotFP:
     return ParallelSnippetGenerator::generateCodeTemplates(Instr,
                                                        ForbiddenRegisters);
   case X86II::ZeroArgFP: