Subzero: Decorate the text asm output with register availability info.

src/IceCfgNode.cpp

 //===- subzero/src/IceCfgNode.cpp - Basic block (node) implementation -----===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the CfgNode class, including the complexities
@@ skipping 738 matching lines @@
 }
 
 // If this node contains only deleted instructions, and ends in an
 // unconditional branch, contract the node by repointing all its
 // in-edges to its successor.
 void CfgNode::contractIfEmpty() {
   if (InEdges.size() == 0)
     return;
   Inst *Branch = NULL;
   for (Inst *I : Insts) {
-    if (!I->isDeleted() && !I->isUnconditionalBranch())
+    if (I->isDeleted())
+      continue;
+    if (I->isUnconditionalBranch())
+      Branch = I;
+    else if (!I->isRedundantAssign())
       return;
-    Branch = I;
   }
   Branch->setDeleted();
   assert(OutEdges.size() == 1);
   // Repoint all this node's in-edges to this node's successor.
   for (CfgNode *Pred : InEdges) {
     for (auto I = Pred->OutEdges.begin(), E = Pred->OutEdges.end(); I != E;
          ++I) {
       if (*I == this) {
         *I = OutEdges[0];
         OutEdges[0]->InEdges.push_back(Pred);
@@ skipping 19 matching lines @@
   // (currently not the case for x86 lowering).
   for (Inst *I : Insts) {
     if (!I->isDeleted()) {
       Target->doBranchOpt(I, NextNode);
     }
   }
 }
 
 // ======================== Dump routines ======================== //
 
+namespace {
+
+// Helper functions for emit().
+
+void emitRegisterUsage(Ostream &Str, const Cfg *Func, const CfgNode *Node,
+                       bool IsLiveIn, std::vector<SizeT> &LiveRegCount) {
+  Liveness *Liveness = Func->getLiveness();
+  const LivenessBV *Live;
+  if (IsLiveIn) {
+    Live = &Liveness->getLiveIn(Node);
+    Str << "\t\t\t\t# LiveIn=";
+  } else {
+    Live = &Liveness->getLiveOut(Node);
+    Str << "\t\t\t\t# LiveOut=";
+  }
+  if (!Live->empty()) {
+    bool First = true;
+    for (SizeT i = 0; i < Live->size(); ++i) {
+      if ((*Live)[i]) {
+        Variable *Var = Liveness->getVariable(i, Node);
+        if (Var->hasReg()) {
+          if (IsLiveIn)
+            ++LiveRegCount[Var->getRegNum()];
+          if (!First)
+            Str << ",";
+          First = false;
+          Var->emit(Func);
+        }
+      }
+    }
+  }
+  Str << "\n";
+}
+
+void emitLiveRangesEnded(Ostream &Str, const Cfg *Func, const Inst *Instr,
+                         std::vector<SizeT> &LiveRegCount) {
+  bool First = true;
+  Variable *Dest = Instr->getDest();
+  if (Dest && Dest->hasReg())
+    ++LiveRegCount[Dest->getRegNum()];
+  for (SizeT I = 0; I < Instr->getSrcSize(); ++I) {
+    Operand *Src = Instr->getSrc(I);
+    SizeT NumVars = Src->getNumVars();
+    for (SizeT J = 0; J < NumVars; ++J) {
+      const Variable *Var = Src->getVar(J);
+      if (Var->hasReg()) {
+        if (Instr->isLastUse(Var) &&
+            --LiveRegCount[Var->getRegNum()] == 0) {
+          if (First)
+            Str << " \t# END=";
+          else
+            Str << ",";
+          Var->emit(Func);
+          First = false;
+        }
+      }
+    }
+  }
+}
+
+} // end of anonymous namespace
+
 void CfgNode::emit(Cfg *Func) const {
   Func->setCurrentNode(this);
   Ostream &Str = Func->getContext()->getStrEmit();
+  Liveness *Liveness = Func->getLiveness();
+  bool DecorateAsm = Liveness && Func->getContext()->getFlags().DecorateAsm;
   if (Func->getEntryNode() == this) {
     Str << Func->getContext()->mangleName(Func->getFunctionName()) << ":\n";
   }
   Str << getAsmName() << ":\n";
   if (Func->useIntegratedAssembler()) {
     Assembler *Asm = Func->getAssembler<Assembler>();
     Asm->BindCfgNodeLabel(getIndex());
   }
+  std::vector<SizeT> LiveRegCount(Func->getTarget()->getNumRegisters());
+  if (DecorateAsm)
+    emitRegisterUsage(Str, Func, this, true, LiveRegCount);
+
   for (InstPhi *Phi : Phis) {
     if (Phi->isDeleted())
       continue;
     // Emitting a Phi instruction should cause an error.
     Inst *Instr = Phi;
     Instr->emit(Func);
   }
   for (Inst *I : Insts) {
     if (I->isDeleted())
       continue;
+    if (I->isRedundantAssign()) {
+      Variable *Dest = I->getDest();
+      if (DecorateAsm && Dest->hasReg() && !I->isLastUse(I->getSrc(0)))
+        ++LiveRegCount[Dest->getRegNum()];
+      continue;
+    }
     if (Func->useIntegratedAssembler()) {
       I->emitIAS(Func);
     } else {
       I->emit(Func);
+      if (DecorateAsm)
+        emitLiveRangesEnded(Str, Func, I, LiveRegCount);
       Str << "\n";
     }
     // Update emitted instruction count, plus fill/spill count for
     // Variable operands without a physical register.
     if (uint32_t Count = I->getEmitInstCount()) {
       Func->getContext()->statsUpdateEmitted(Count);
       if (Variable *Dest = I->getDest()) {
         if (!Dest->hasReg())
           Func->getContext()->statsUpdateFills();
       }
       for (SizeT S = 0; S < I->getSrcSize(); ++S) {
         if (Variable *Src = llvm::dyn_cast<Variable>(I->getSrc(S))) {
           if (!Src->hasReg())
             Func->getContext()->statsUpdateSpills();
         }
       }
     }
   }
+  if (DecorateAsm)
+    emitRegisterUsage(Str, Func, this, false, LiveRegCount);
 }
 
 void CfgNode::dump(Cfg *Func) const {
   Func->setCurrentNode(this);
   Ostream &Str = Func->getContext()->getStrDump();
   Liveness *Liveness = Func->getLiveness();
   if (Func->getContext()->isVerbose(IceV_Instructions)) {
     Str << getName() << ":\n";
   }
   // Dump list of predecessor nodes.
@@ skipping 59 matching lines @@
       if (!First)
         Str << ", ";
       First = false;
       Str << "%" << I->getName();
     }
     Str << "\n";
   }
 }
 
 } // end of namespace Ice