Subzero: Also dump live-end info for stack vars under -asm-verbose.

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 806 matching lines @@
     return;
   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;
-        }
+      if (Instr->isLastUse(Var) &&
+          (!Var->hasReg() || --LiveRegCount[Var->getRegNum()] == 0)) {
+        if (First)
+          Str << " \t# END=";
+        else
+          Str << ",";
+        Var->emit(Func);
+        First = false;
       }
     }
   }
 }
 
 void updateStats(Cfg *Func, const Inst *I) {
   if (!ALLOW_DUMP)
     return;
   // Update emitted instruction count, plus fill/spill count for
   // Variable operands without a physical register.
@@ skipping 17 matching lines @@
 void CfgNode::emit(Cfg *Func) const {
   if (!ALLOW_DUMP)
     return;
   Func->setCurrentNode(this);
   Ostream &Str = Func->getContext()->getStrEmit();
   Liveness *Liveness = Func->getLiveness();
   bool DecorateAsm =
       Liveness && Func->getContext()->getFlags().getDecorateAsm();
   Str << getAsmName() << ":\n";
   std::vector<SizeT> LiveRegCount(Func->getTarget()->getNumRegisters());
-  if (DecorateAsm)
-    emitRegisterUsage(Str, Func, this, true, LiveRegCount);
+  if (DecorateAsm) {
+    const bool IsLiveIn = true;
+    emitRegisterUsage(Str, Func, this, IsLiveIn, LiveRegCount);
+  }
 
   for (const Inst &I : Phis) {
     if (I.isDeleted())
       continue;
     // Emitting a Phi instruction should cause an error.
     I.emit(Func);
   }
   for (const 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;
     }
     I.emit(Func);
     if (DecorateAsm)
       emitLiveRangesEnded(Str, Func, &I, LiveRegCount);
     Str << "\n";
     updateStats(Func, &I);
   }
-  if (DecorateAsm)
-    emitRegisterUsage(Str, Func, this, false, LiveRegCount);
+  if (DecorateAsm) {
+    const bool IsLiveIn = false;
+    emitRegisterUsage(Str, Func, this, IsLiveIn, LiveRegCount);
+  }
 }
 
 // Helper class for emitIAS().
 namespace {
 class BundleEmitHelper {
   BundleEmitHelper() = delete;
   BundleEmitHelper(const BundleEmitHelper &) = delete;
   BundleEmitHelper &operator=(const BundleEmitHelper &) = delete;
 
 public:
@@ skipping 290 matching lines @@
       if (!First)
         Str << ", ";
       First = false;
       Str << "%" << I->getName();
     }
     Str << "\n";
   }
 }
 
 } // end of namespace Ice