[X86] Simplify isReplaceable (NFC)

[kazu]

Summary

isReplaceable checks to see if every use of the second LEA (called
"Last" in the function) is as the base address of a respective memory
access instruction.

The "for" loop being deleted in this patch potentially checks every
operand of the use instruction.

The patch simplifies the code by checking to see if every use is as
the base address of a respective memory access instruction, which we
can do with a quick pointer comparison.

[kazu]

Please take a look. Thanks!

[pengfei]

llvm/lib/Target/X86/X86OptimizeLEAs.cpp

464

This cannot prevent def register been used by other operands at the same time.

[kazu]

llvm/lib/Target/X86/X86OptimizeLEAs.cpp

464

This cannot prevent def register been used by other operands at the same time.

Sure, a single iteration of the "for" loop may not prevent the def register being used by other operands, but if we check to see if all uses are used as the address base register, then no use is left for any other purpose. Or it it possible that some uses are not counted in the use list?

[pengfei]

llvm/lib/Target/X86/X86OptimizeLEAs.cpp

464

I see your point. But I don't know. I have some concerns, e.g., if their pointer are always unique? It is fragile given not guaranteed by API/doc. And if pointer comparison is stable enough, why is isIdenticalTo implemented in a complex way?

llvm/lib/Target/X86/X86OptimizeLEAs.cpp

bool X86OptimizeLEAPass::isReplaceable(const MachineInstr &First,
   // Make sure that LEA def registers belong to the same class. There may be
   // instructions (like MOV8mr_NOREX) which allow a limited set of registers to
   // be used as their operands, so we must be sure that replacing one LEA
   // with another won't lead to putting a wrong register in the instruction.
   if (MRI->getRegClass(First.getOperand(0).getReg()) !=
       MRI->getRegClass(Last.getOperand(0).getReg()))
     return false;
 
+  // We don't deal with physical registers.
+  if (Register::isPhysicalRegister(Last.getOperand(0).getReg()))
+    return false;
+
   // Get new address displacement.
   AddrDispShift = getAddrDispShift(Last, 1, First, 1);
 
   // Loop over all uses of the Last LEA to check that its def register is
   // used only as address base for memory accesses. If so, it can be
   // replaced, otherwise - no.
   for (auto &MO : MRI->use_nodbg_operands(Last.getOperand(0).getReg())) {
     MachineInstr &MI = *MO.getParent();
 
     // Get the number of the first memory operand.
     const MCInstrDesc &Desc = MI.getDesc();
     int MemOpNo = X86II::getMemoryOperandNo(Desc.TSFlags);
 
     // If the use instruction has no memory operand - the LEA is not
     // replaceable.
     if (MemOpNo < 0)
       return false;
 
     MemOpNo += X86II::getOperandBias(Desc);
 
-    // If the address base of the use instruction is not the LEA def register -
+    // If this use does not come from the address base of the use instruction,
     // the LEA is not replaceable.
-    if (!isIdenticalOp(MI.getOperand(MemOpNo + X86::AddrBaseReg), MO))
-      return false;
-
-    // If the LEA def register is used as any other operand of the use
-    // instruction - the LEA is not replaceable.
-    for (unsigned i = 0; i < MI.getNumOperands(); i++)
-      if (i != (unsigned)(MemOpNo + X86::AddrBaseReg) &&
-          isIdenticalOp(MI.getOperand(i), MO))
-        return false;
+    if (&MO != &MI.getOperand(MemOpNo + X86::AddrBaseReg))
 
     // Check that the new address displacement will fit 4 bytes.
     if (MI.getOperand(MemOpNo + X86::AddrDisp).isImm() &&
         !isInt<32>(MI.getOperand(MemOpNo + X86::AddrDisp).getImm() +
                    AddrDispShift))
       return false;
   }