Subzero: Fix srem.i8/urem.i8 lowering for x86-64.

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 73 matching lines @@
 }
 
 int32_t findMinWeightIndex(
     const SmallBitVector &RegMask,
     const llvm::SmallVector<RegWeight, LinearScan::REGS_SIZE> &Weights) {
   int MinWeightIndex = -1;
   for (RegNumT i : RegNumBVIter(RegMask)) {
     if (MinWeightIndex < 0 || Weights[i] < Weights[MinWeightIndex])
       MinWeightIndex = i;
   }
-  assert(MinWeightIndex >= 0);
+  assert(getFlags().getRegAllocReserve() || MinWeightIndex >= 0);
   return MinWeightIndex;
 }
 
 } // end of anonymous namespace
 
 LinearScan::LinearScan(Cfg *Func)
     : Func(Func), Ctx(Func->getContext()), Target(Func->getTarget()),
       Verbose(BuildDefs::dump() && Func->isVerbose(IceV_LinearScan)),
       UseReserve(getFlags().getRegAllocReserve()) {}
 
@@ skipping 574 matching lines @@
     const auto &Aliases = *RegAliases[Item->getRegNumTmp()];
     RegWeight W = Item->getWeight(Func);
     for (RegNumT RegAlias : RegNumBVIter(Aliases)) {
       Iter.Weights[RegAlias].addWeight(W);
     }
   }
 
   // All the weights are now calculated. Find the register with smallest weight.
   int32_t MinWeightIndex = findMinWeightIndex(Iter.RegMask, Iter.Weights);
 
-  if (Iter.Cur->getWeight(Func) <= Iter.Weights[MinWeightIndex]) {
+  if (MinWeightIndex < 0 ||
+      Iter.Cur->getWeight(Func) <= Iter.Weights[MinWeightIndex]) {
     if (!Iter.Cur->mustHaveReg()) {
       // Iter.Cur doesn't have priority over any other live ranges, so don't
       // allocate any register to it, and move it to the Handled state.
       Handled.push_back(Iter.Cur);
       return;
     }
     if (Kind == RAK_Phi) {
       // Iter.Cur is infinite-weight but all physical registers are already
       // taken, so we need to force one to be temporarily available.
       addSpillFill(Iter);
@@ skipping 163 matching lines @@
 
   // Allocate memory once outside the loop.
   IterationState Iter;
   Iter.Weights.reserve(NumRegisters);
   Iter.PrecoloredUnhandledMask.reserve(NumRegisters);
 
   while (!Unhandled.empty()) {
     Iter.Cur = Unhandled.back();
     Unhandled.pop_back();
     dumpLiveRangeTrace("\nConsidering  ", Iter.Cur);
-    assert(Target->getRegistersForVariable(Iter.Cur).any());
+    if (UseReserve)
+      assert(Target->getAllRegistersForVariable(Iter.Cur).any());
+    else
+      assert(Target->getRegistersForVariable(Iter.Cur).any());
     Iter.RegMask = RegMaskFull & Target->getRegistersForVariable(Iter.Cur);
     Iter.RegMaskUnfiltered =
         RegMaskFull & Target->getAllRegistersForVariable(Iter.Cur);
     KillsRange.trim(Iter.Cur->getLiveRange().getStart());
 
     // Check for pre-colored ranges. If Cur is pre-colored, it definitely gets
     // that register. Previously processed live ranges would have avoided that
     // register due to it being pre-colored. Future processed live ranges won't
     // evict that register because the live range has infinite weight.
     if (Iter.Cur->hasReg()) {
@@ skipping 130 matching lines @@
     Str << "\n";
   }
   Str << "++++++ Inactive:\n";
   for (const Variable *Item : Inactive) {
     dumpLiveRange(Item, Func);
     Str << "\n";
   }
 }
 
 } // end of namespace Ice