[X86] Add option for enabling LEA optimization pass

[aturetsk]

Summary

Add option to enable/disable LEA optimization pass. By default the pass is disabled.

[• dberlin]

Out of curiosity, are there actually plans to make this faster?
(Since it would be non-ideal to have this disabled by default but in-tree
forever)

[qcolombet]

LGTM plus what Daniel said!

Q.

[aturetsk]

I'm going to investigate the compile time issue and try to find ways to improve pass's speed.
In the worst case we can just skip LEA optimization for big basic blocks, that should keep compile time from blowing up.

[• dberlin]

In D15573#312043, @aturetsk wrote:

I'm going to investigate the compile time issue and try to find ways to improve pass's speed.
In the worst case we can just skip LEA optimization for big basic blocks, that should keep compile time from blowing up.

I would try the two things i suggested in the bug. They solve the main algorithmic complexity problems with this pass. I hacked up a patch to do them, and it completely solved the compile time issue, and i didn't see any regressions.

IMHO, We generally should only be inserting big-hammer compile time controls and random "stop after 10" style things if we can't reasonably make the algorithmic complexity better.
(among other reasons, we end up with a compiler that has sudden changes in optimization behavior depending on if your block has 999 instructions or 1000 instructions)

llvm/trunk/lib/Target/X86/X86OptimizeLEAs.cpp

 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetInstrInfo.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "x86-optimize-LEAs"
 
+static cl::opt<bool> EnableX86LEAOpt("enable-x86-lea-opt", cl::Hidden,
+                                     cl::desc("X86: Enable LEA optimizations."),
+                                     cl::init(false));
+
 STATISTIC(NumSubstLEAs, "Number of LEA instruction substitutions");
 
 namespace {
 class OptimizeLEAPass : public MachineFunctionPass {
 public:
   OptimizeLEAPass() : MachineFunctionPass(ID) {}
 
   const char *getPassName() const override { return "X86 LEA Optimize"; }
bool OptimizeLEAPass::removeRedundantAddrCalc(
 
   return Changed;
 }
 
 bool OptimizeLEAPass::runOnMachineFunction(MachineFunction &MF) {
   bool Changed = false;
 
   // Perform this optimization only if we care about code size.
-  if (!MF.getFunction()->optForSize())
+  if (!EnableX86LEAOpt || !MF.getFunction()->optForSize())
     return false;
 
   MRI = &MF.getRegInfo();
   TII = MF.getSubtarget<X86Subtarget>().getInstrInfo();
   TRI = MF.getSubtarget<X86Subtarget>().getRegisterInfo();
 
   // Process all basic blocks.
   for (auto &MBB : MF) {

llvm/trunk/test/CodeGen/X86/lea-opt.ll

-; RUN: llc < %s -mtriple=x86_64-linux | FileCheck %s
+; RUN: llc < %s -mtriple=x86_64-linux -enable-x86-lea-opt | FileCheck %s
 
 %struct.anon1 = type { i32, i32, i32 }
 %struct.anon2 = type { i32, [32 x i32], i32 }
 
 @arr1 = external global [65 x %struct.anon1], align 16
 @arr2 = external global [65 x %struct.anon2], align 16
 
 define void @test1(i64 %x) nounwind {