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 569 matching lines @@
         : InstX86Base(Func, K, 1, llvm::dyn_cast<Variable>(SrcDest)) {
       this->addSource(SrcDest);
     }
 
   private:
     static const char *Opcode;
     static const GPREmitterOneOp Emitter;
   };
 
   /// Instructions of the form x := op(y).
+  class InstX86Add;
   template <typename InstX86Base::InstKindX86 K>
   class InstX86BaseUnaryopGPR : public InstX86Base {
     InstX86BaseUnaryopGPR() = delete;
     InstX86BaseUnaryopGPR(const InstX86BaseUnaryopGPR &) = delete;
     InstX86BaseUnaryopGPR &operator=(const InstX86BaseUnaryopGPR &) = delete;
 
   public:
     using Base = InstX86BaseUnaryopGPR<K>;
 
     void emit(const Cfg *Func) const override {
@@ skipping 13 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);
     }
 
+    InstX86Add *deoptLeaToAddOrNull(const Cfg *Func) const {

[Jim Stichnoth, 2016/08/02 03:43:52]

I think you could just declare this to return Inst*, then you could get rid of
the forward class declaration above.

[manasijm, 2016/08/02 16:08:36]

Done.

+      // Revert back to Add when the Lea is a 2-address instruction.
+      // Caller has to emit, this just produces the add instruction.
+      auto *MemOp = llvm::dyn_cast<X86OperandMem>(this->getSrc(0));

[Jim Stichnoth, 2016/08/02 03:43:52]

if (auto *MemOp = llvm::dyn_cast<X86OperandMem>(this->getSrc(0))) {
  if (getFlags() ... ) {
    ...
    return ... ;
  }
}
return nullptr;

[manasijm, 2016/08/02 16:08:36]

Done.

+      if (MemOp != nullptr && 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