Subzero: Improve usability of liveness-related tools.

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.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 680 matching lines @@
                                    InstNumberT LastInstNum) {
   TimerMarker T1(TimerStack::TT_liveRange, Func);
 
   SizeT NumVars = Liveness->getNumVarsInNode(this);
   LivenessBV &LiveIn = Liveness->getLiveIn(this);
   LivenessBV &LiveOut = Liveness->getLiveOut(this);
   LiveBeginEndMap &MapBegin = *Liveness->getLiveBegin(this);
   LiveBeginEndMap &MapEnd = *Liveness->getLiveEnd(this);
   std::sort(MapBegin.begin(), MapBegin.end());
   std::sort(MapEnd.begin(), MapEnd.end());
-  // Verify there are no duplicates.
-  auto ComparePair =
-      [](const LiveBeginEndMapEntry &A, const LiveBeginEndMapEntry &B) {
-        return A.first == B.first;
-      };
-  (void)ComparePair;
-  assert(std::adjacent_find(MapBegin.begin(), MapBegin.end(), ComparePair) ==
-         MapBegin.end());
-  assert(std::adjacent_find(MapEnd.begin(), MapEnd.end(), ComparePair) ==
-         MapEnd.end());
+  if (BuildDefs::asserts()) {

[John, 2015/09/25 23:02:16]

this would be easier to read (I think) if written as

if (!asserts())
  return;

failure = std::adjacent_find() != ..

if (!dump()) {
  assert(!failure);
  return;
}

if (!failure)
  return;

for (...)

It is easier to read if you don't have several nesting levels.

[Jim Stichnoth, 2015/09/25 23:56:01]

Done.

+    // Verify there are no duplicates.
+    auto ComparePair =
+        [](const LiveBeginEndMapEntry &A, const LiveBeginEndMapEntry &B) {
+          return A.first == B.first;
+        };
+    if (std::adjacent_find(MapBegin.begin(), MapBegin.end(), ComparePair) !=
+            MapBegin.end() ||
+        std::adjacent_find(MapEnd.begin(), MapEnd.end(), ComparePair) !=
+            MapEnd.end()) {
+      // There is definitely a liveness error.  Print all the errors.
+      if (BuildDefs::dump()) {
+        GlobalContext *Ctx = Func->getContext();
+        OstreamLocker L(Ctx);
+        Ostream &Str = Ctx->getStrDump();
+        if (Func->isVerbose()) {
+          Str << "Live range errors in the following block:\n";
+          dump(Func);
+        }
+        for (auto Start = MapBegin.begin();
+             (Start = std::adjacent_find(Start, MapBegin.end(), ComparePair)) !=
+             MapBegin.end();
+             ++Start) {
+          auto Next = Start + 1;
+          Str << "Duplicate LR begin, block " << getName() << ", instructions "
+              << Start->second << " & " << Next->second << ", variable "
+              << Liveness->getVariable(Start->first, this)->getName(Func)
+              << "\n";
+        }
+        for (auto Start = MapEnd.begin();
+             (Start = std::adjacent_find(Start, MapEnd.end(), ComparePair)) !=
+             MapEnd.end();
+             ++Start) {
+          auto Next = Start + 1;
+          Str << "Duplicate LR end,   block " << getName() << ", instructions "
+              << Start->second << " & " << Next->second << ", variable "
+              << Liveness->getVariable(Start->first, this)->getName(Func)
+              << "\n";
+        }
+      }
+      llvm::report_fatal_error("livenessAddIntervals: Liveness error");
+    }
+  }
 
   LivenessBV LiveInAndOut = LiveIn;
   LiveInAndOut &= LiveOut;
 
   // Iterate in parallel across the sorted MapBegin[] and MapEnd[].
   auto IBB = MapBegin.begin(), IEB = MapEnd.begin();
   auto IBE = MapBegin.end(), IEE = MapEnd.end();
   while (IBB != IBE || IEB != IEE) {
     SizeT i1 = IBB == IBE ? NumVars : IBB->first;
     SizeT i2 = IEB == IEE ? NumVars : IEB->first;
@@ skipping 147 matching lines @@
   Str << "\n";
 }
 
 void emitLiveRangesEnded(Ostream &Str, const Cfg *Func, const Inst *Instr,
                          CfgVector<SizeT> &LiveRegCount) {
   if (!BuildDefs::dump())
     return;
   bool First = true;
   Variable *Dest = Instr->getDest();
   // Normally we increment the live count for the dest register. But we
-  // shouldn't if the instruction's IsDestNonKillable flag is set, because this
+  // shouldn't if the instruction's IsDestRedefined flag is set, because this
   // means that the target lowering created this instruction as a non-SSA
   // assignment; i.e., a different, previous instruction started the dest
   // variable's live range.
-  if (!Instr->isDestNonKillable() && Dest && Dest->hasReg())
+  if (!Instr->isDestRedefined() && Dest && Dest->hasReg())
     ++LiveRegCount[Dest->getRegNum()];
   FOREACH_VAR_IN_INST(Var, *Instr) {
     bool ShouldReport = Instr->isLastUse(Var);
     if (ShouldReport && Var->hasReg()) {
       // Don't report end of live range until the live count reaches 0.
       SizeT NewCount = --LiveRegCount[Var->getRegNum()];
       if (NewCount)
         ShouldReport = false;
     }
     if (ShouldReport) {
@@ skipping 410 matching lines @@
   InstIntrinsicCall *Inst = InstIntrinsicCall::create(
       Func, 5, Func->makeVariable(IceType_i64), RMWI64Name, Info->Info);
   Inst->addArg(AtomicRMWOp);
   Inst->addArg(Counter);
   Inst->addArg(One);
   Inst->addArg(OrderAcquireRelease);
   Insts.push_front(Inst);
 }
 
 } // end of namespace Ice