Subzero: Improve usability of liveness-related tools.

src/IceRegAlloc.cpp

 //===- subzero/src/IceRegAlloc.cpp - Linear-scan implementation -----------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 114 matching lines @@
   for (CfgNode *Node : Func->getNodes()) {
     for (Inst &I : Node->getInsts()) {
       if (auto Kill = llvm::dyn_cast<InstFakeKill>(&I)) {
         if (!Kill->isDeleted() && !Kill->getLinked()->isDeleted())
           Kills.push_back(I.getNumber());
       }
     }
   }
 }
 
+// Validate the integrity of the live ranges.  If there are any errors, it
+// prints details and returns false.  On success, it returns true.
+bool LinearScan::livenessValidateIntervals(
+    const DefUseErrorList &DefsWithoutUses,
+    const DefUseErrorList &UsesBeforeDefs,
+    const CfgVector<InstNumberT> &LRBegin,
+    const CfgVector<InstNumberT> &LREnd) {
+  if (DefsWithoutUses.empty() && UsesBeforeDefs.empty())
+    return true;
+
+  if (!BuildDefs::dump())
+    return false;
+
+  const VarList &Vars = Func->getVariables();
+  OstreamLocker L(Ctx);
+  Ostream &Str = Ctx->getStrDump();
+  for (SizeT VarNum : DefsWithoutUses) {
+    Variable *Var = Vars[VarNum];
+    Str << "LR def without use, instruction " << LRBegin[VarNum]
+        << ", variable " << Var->getName(Func) << "\n";
+  }
+  for (SizeT VarNum : UsesBeforeDefs) {
+    Variable *Var = Vars[VarNum];
+    Str << "LR use before def, instruction " << LREnd[VarNum] << ", variable "
+        << Var->getName(Func) << "\n";
+  }
+  return false;
+}
+
 // Prepare for very simple register allocation of only infinite-weight
 // Variables while respecting pre-colored Variables. Some properties we take
 // advantage of:
 //
 // * Live ranges of interest consist of a single segment.
 //
 // * Live ranges of interest never span a call instruction.
 //
 // * Phi instructions are not considered because either phis have already been
 //   lowered, or they don't contain any pre-colored or infinite-weight
@@ skipping 16 matching lines @@
   TimerMarker T(TimerStack::TT_initUnhandled, Func);
   FindPreference = false;
   FindOverlap = false;
   SizeT NumVars = 0;
   const VarList &Vars = Func->getVariables();
 
   // Iterate across all instructions and record the begin and end of the live
   // range for each variable that is pre-colored or infinite weight.
   CfgVector<InstNumberT> LRBegin(Vars.size(), Inst::NumberSentinel);
   CfgVector<InstNumberT> LREnd(Vars.size(), Inst::NumberSentinel);
+  DefUseErrorList DefsWithoutUses, UsesBeforeDefs;
   for (CfgNode *Node : Func->getNodes()) {
     for (Inst &Inst : Node->getInsts()) {
       if (Inst.isDeleted())
         continue;
+      FOREACH_VAR_IN_INST(Var, Inst) {
+        if (Var->getIgnoreLiveness())
+          continue;
+        if (Var->hasReg() || Var->mustHaveReg()) {
+          SizeT VarNum = Var->getIndex();
+          LREnd[VarNum] = Inst.getNumber();
+          if (!Var->getIsArg() && LRBegin[VarNum] == Inst::NumberSentinel)
+            UsesBeforeDefs.push_back(VarNum);
+        }
+      }
       if (const Variable *Var = Inst.getDest()) {
         if (!Var->getIgnoreLiveness() &&
             (Var->hasReg() || Var->mustHaveReg())) {
           if (LRBegin[Var->getIndex()] == Inst::NumberSentinel) {
             LRBegin[Var->getIndex()] = Inst.getNumber();
             ++NumVars;
           }
         }
       }
-      FOREACH_VAR_IN_INST(Var, Inst) {
-        if (Var->getIgnoreLiveness())
-          continue;
-        if (Var->hasReg() || Var->mustHaveReg())
-          LREnd[Var->getIndex()] = Inst.getNumber();
-      }
     }
   }
 
   Unhandled.reserve(NumVars);
   UnhandledPrecolored.reserve(NumVars);
   for (SizeT i = 0; i < Vars.size(); ++i) {
     Variable *Var = Vars[i];
     if (LRBegin[i] != Inst::NumberSentinel) {
-      assert(LREnd[i] != Inst::NumberSentinel);
+      if (LREnd[i] == Inst::NumberSentinel) {
+        DefsWithoutUses.push_back(i);
+        continue;
+      }
       Unhandled.push_back(Var);
       Var->resetLiveRange();
       Var->addLiveRange(LRBegin[i], LREnd[i]);
       Var->untrimLiveRange();
       if (Var->hasReg()) {
         Var->setRegNumTmp(Var->getRegNum());
         Var->setMustHaveReg();
         UnhandledPrecolored.push_back(Var);
       }
       --NumVars;
     }
   }
+
+  if (!livenessValidateIntervals(DefsWithoutUses, UsesBeforeDefs, LRBegin,
+                                 LREnd)) {
+    llvm::report_fatal_error("initForInfOnly: Liveness error");
+    return;
+  }
+
+  if (!DefsWithoutUses.empty() || !UsesBeforeDefs.empty()) {
+    if (BuildDefs::dump()) {
+      OstreamLocker L(Ctx);
+      Ostream &Str = Ctx->getStrDump();
+      for (SizeT VarNum : DefsWithoutUses) {
+        Variable *Var = Vars[VarNum];
+        Str << "LR def without use, instruction " << LRBegin[VarNum]
+            << ", variable " << Var->getName(Func) << "\n";
+      }
+      for (SizeT VarNum : UsesBeforeDefs) {
+        Variable *Var = Vars[VarNum];
+        Str << "LR use before def, instruction " << LREnd[VarNum]
+            << ", variable " << Var->getName(Func) << "\n";
+      }
+    }
+    llvm::report_fatal_error("initForInfOnly: Liveness error");
+  }
   // This isn't actually a fatal condition, but it would be nice to know if we
   // somehow pre-calculated Unhandled's size wrong.
   assert(NumVars == 0);
 
   // Don't build up the list of Kills because we know that no infinite-weight
   // Variable has a live range spanning a call.
   Kills.clear();
 }
 
 void LinearScan::init(RegAllocKind Kind) {
@@ skipping 662 matching lines @@
     Str << "\n";
   }
   Str << "++++++ Inactive:\n";
   for (const Variable *Item : Inactive) {
     dumpLiveRange(Item, Func);
     Str << "\n";
   }
 }
 
 } // end of namespace Ice