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->isUnconditionalBranch())

[jvoung (off chromium), 2014/10/31 16:56:42]

This doesn't seem to check anymore if the UnconditionalBranch is not deleted. If
there are multiple UnconditionalBranches, all but one should be deleted, but
this depends on the last one being the non-deleted one?

[Jim Stichnoth, 2014/11/01 14:49:40]

Ouch, done.

I should try to make InstList into a container whose iterator by default
automatically skips over deleted instructions.

+      Branch = I;
+    else if (!I->isDeleted() && !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 function for emit().
+void emitRegisterUsage(Ostream &Str, Cfg *Func, const CfgNode *Node,

[jvoung (off chromium), 2014/10/31 16:56:42]

Func can be const?

[Jim Stichnoth, 2014/11/01 14:49:40]

Done.

+                       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";
+}
+
+} // 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) {
+        // Add end-of-live-range comment.
+        bool First = true;
+        Inst *Instr = I;

[jvoung (off chromium), 2014/10/31 16:56:42]

Can this be factored out into a function too?

At some point, I'm wondering if emitIAS should be factored out into a
Cfg::emitIAS() instead of being part of Cfg::emit(). At least there are some
things like this that wouldn't make sense for it, and I'm still figuring out how
to tie it into the object file container generation after filling the buffer --
something that wouldn't have to be done for emit().

[Jim Stichnoth, 2014/11/01 14:49:40]

Done.
Yes, I think that's a good idea.  Another benefit is that it should make it
easier to #ifdef out all the textual emit() code in a minimal build.

+        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;
+              }
+            }
+          }
+        }
+      }
       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