Subzero: Use register availability during lowering to improve the code.

src/IceTargetLowering.cpp

 //===- subzero/src/IceTargetLowering.cpp - Basic lowering implementation --===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 28 matching lines @@
   End = getNode()->getInsts().end();
   rewind();
   advanceForward(Next);
 }
 
 void LoweringContext::rewind() {
   Begin = getNode()->getInsts().begin();
   Cur = Begin;
   skipDeleted(Cur);
   Next = Cur;
+  availabilityReset();
 }
 
 void LoweringContext::insert(Inst *Inst) {
   getNode()->getInsts().insert(Next, Inst);
   LastInserted = Inst;
 }
 
 void LoweringContext::skipDeleted(InstList::iterator &I) const {
   while (I != End && I->isDeleted())
     ++I;
 }
 
 void LoweringContext::advanceForward(InstList::iterator &I) const {
   if (I != End) {
     ++I;
     skipDeleted(I);
   }
 }
 
 Inst *LoweringContext::getLastInserted() const {
   assert(LastInserted);
   return LastInserted;
 }
 
+void LoweringContext::availabilityReset() {
+  LastDest = nullptr;
+  LastSrc = nullptr;
+}
+
+void LoweringContext::availabilityUpdate() {
+  availabilityReset();
+  Inst *Instr = LastInserted;
+  if (Instr == nullptr)
+    return;
+  if (!Instr->isSimpleAssign())
+    return;
+  if (auto *SrcVar = llvm::dyn_cast<Variable>(Instr->getSrc(0))) {
+    LastDest = Instr->getDest();
+    LastSrc = SrcVar;
+  }
+}
+
+Variable *LoweringContext::availabilityGet(Operand *Src) const {
+  assert(Src);
+  if (Src == LastDest)
+    return LastSrc;
+  return nullptr;
+}
+
 TargetLowering *TargetLowering::createLowering(TargetArch Target, Cfg *Func) {
 #define SUBZERO_TARGET(X)                                                      \
   if (Target == Target_##X)                                                    \
     return Target##X::create(Func);
 #include "llvm/Config/SZTargets.def"
 
   Func->setError("Unsupported target");
   return nullptr;
 }
 
@@ skipping 511 matching lines @@
   if (Target == Target_##X)                                                    \
     return TargetHeader##X::create(Ctx);
 #include "llvm/Config/SZTargets.def"
 
   llvm::report_fatal_error("Unsupported target header lowering");
 }
 
 TargetHeaderLowering::~TargetHeaderLowering() = default;
 
 } // end of namespace Ice