Subzero: Fix/improve -asm-verbose output.

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 776 matching lines @@
   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;
+    std::vector<Variable *> LiveRegs;
     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);
+          LiveRegs.push_back(Var);
         }
       }
     }
+    // Sort the variables by regnum so they are always printed in a
+    // familiar order.
+    std::sort(LiveRegs.begin(), LiveRegs.end(),
+              [](const Variable *V1, const Variable *V2) {
+      return V1->getRegNum() < V2->getRegNum();
+    });
+    bool First = true;
+    for (Variable *Var : LiveRegs) {
+      if (!First)
+        Str << ",";
+      First = false;
+      Var->emit(Func);
+    }
   }
   Str << "\n";
 }
 
 void emitLiveRangesEnded(Ostream &Str, const Cfg *Func, const Inst *Instr,
                          std::vector<SizeT> &LiveRegCount) {
   if (!ALLOW_DUMP)
     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 (Instr->isLastUse(Var) &&
-          (!Var->hasReg() || --LiveRegCount[Var->getRegNum()] == 0)) {
+      bool ShouldEmit = Instr->isLastUse(Var);
+      if (Var->hasReg()) {
+        // Don't report end of live range until the live count reaches 0.
+        SizeT NewCount = --LiveRegCount[Var->getRegNum()];
+        if (NewCount)
+          ShouldEmit = false;
+      }
+      if (ShouldEmit) {
         if (First)
           Str << " \t# END=";
         else
           Str << ",";
         Var->emit(Func);
         First = false;
       }
     }
   }
 }
@@ skipping 37 matching lines @@
 
   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()];
+    if (I.isRedundantAssign())
       continue;
-    }
     I.emit(Func);
     if (DecorateAsm)
       emitLiveRangesEnded(Str, Func, &I, LiveRegCount);
     Str << "\n";
     updateStats(Func, &I);
   }
   if (DecorateAsm) {
     const bool IsLiveIn = false;
     emitRegisterUsage(Str, Func, this, IsLiveIn, LiveRegCount);
   }
@@ skipping 300 matching lines @@
       if (!First)
         Str << ", ";
       First = false;
       Str << "%" << I->getName();
     }
     Str << "\n";
   }
 }
 
 } // end of namespace Ice