Subzero: Aggressive LEA

src/IceInstX86Base.h

 //===- subzero/src/IceInstX86Base.h - Generic x86 instructions -*- C++ -*--===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 602 matching lines @@
       this->getSrc(0)->emit(Func);
       Str << ", ";
       this->getDest()->emit(Func);
     }
     void emitIAS(const Cfg *Func) const override {
       assert(this->getSrcSize() == 1);
       const Variable *Var = this->getDest();
       Type Ty = Var->getType();
       const Operand *Src = this->getSrc(0);
       constexpr bool IsLea = K == InstX86Base::Lea;
+
+      if (IsLea) {
+        if (auto *Add = deoptLeaToAddOrNull(Func)) {
+          Add->emitIAS(Func);
+          return;
+        }
+      }
       emitIASRegOpTyGPR(Func, IsLea, Ty, Var, Src, Emitter);
     }
     void dump(const Cfg *Func) const override {
       if (!BuildDefs::dump())
         return;
       Ostream &Str = Func->getContext()->getStrDump();
       this->dumpDest(Func);
       Str << " = " << Opcode << "." << this->getSrc(0)->getType() << " ";
       this->dumpSources(Func);
     }
+
     static bool classof(const Inst *Instr) {
       return InstX86Base::isClassof(Instr, InstX86Base::K);
     }
 
   protected:
     InstX86BaseUnaryopGPR(Cfg *Func, Variable *Dest, Operand *Src)
         : InstX86Base(Func, K, 1, Dest) {
       this->addSource(Src);
     }
 
+    Inst *deoptLeaToAddOrNull(const Cfg *Func) const {
+      // Revert back to Add when the Lea is a 2-address instruction.
+      // Caller has to emit, this just produces the add instruction.
+      if (auto *MemOp = llvm::dyn_cast<X86OperandMem>(this->getSrc(0))) {
+        if (getFlags().getAggressiveLea() &&
+            MemOp->getBase()->getRegNum() == this->getDest()->getRegNum() &&
+            MemOp->getIndex() == nullptr && MemOp->getShift() == 0) {
+          auto *Add = InstImpl<TraitsType>::InstX86Add::create(
+              const_cast<Cfg *>(Func), this->getDest(), MemOp->getOffset());
+          // TODO(manasijm): Remove const_cast by emitting code for add
+          // directly.
+          return Add;
+        }
+      }
+      return nullptr;
+    }
+
     static const char *Opcode;
     static const GPREmitterRegOp Emitter;
   };
 
   template <typename InstX86Base::InstKindX86 K>
   class InstX86BaseUnaryopXmm : public InstX86Base {
     InstX86BaseUnaryopXmm() = delete;
     InstX86BaseUnaryopXmm(const InstX86BaseUnaryopXmm &) = delete;
     InstX86BaseUnaryopXmm &operator=(const InstX86BaseUnaryopXmm &) = delete;
 
@@ skipping 2958 matching lines @@
           &InstImpl<TraitsType>::Assembler::punpckldq};                        \
   }                                                                            \
   }
 
 } // end of namespace X86NAMESPACE
 } // end of namespace Ice
 
 #include "IceInstX86BaseImpl.h"
 
 #endif // SUBZERO_SRC_ICEINSTX86BASE_H