Use separate random number generator for each randomization pass

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 232 matching lines @@
   case RAK_Global:
   case RAK_Phi:
     initForGlobal();
     break;
   case RAK_InfOnly:
     initForInfOnly();
     break;
   }
 
   auto CompareRanges = [](const Variable *L, const Variable *R) {
-      InstNumberT Lstart = L->getLiveRange().getStart();
-      InstNumberT Rstart = R->getLiveRange().getStart();
-      if (Lstart == Rstart)
-        return L->getIndex() < R->getIndex();
-      return Lstart < Rstart;
+    InstNumberT Lstart = L->getLiveRange().getStart();
+    InstNumberT Rstart = R->getLiveRange().getStart();
+    if (Lstart == Rstart)
+      return L->getIndex() < R->getIndex();
+    return Lstart < Rstart;
   };
   // Do a reverse sort so that erasing elements (from the end) is fast.
   std::sort(Unhandled.rbegin(), Unhandled.rend(), CompareRanges);
   std::sort(UnhandledPrecolored.rbegin(), UnhandledPrecolored.rend(),
             CompareRanges);
 
   Handled.reserve(Unhandled.size());
   Inactive.reserve(Unhandled.size());
   Active.reserve(Unhandled.size());
 }
@@ skipping 501 matching lines @@
   for (Variable *I : Active)
     Handled.push_back(I);
   Active.clear();
   for (Variable *I : Inactive)
     Handled.push_back(I);
   Inactive.clear();
   dump(Func);
 
   llvm::SmallVector<int32_t, REGS_SIZE> Permutation(NumRegisters);
   if (Randomized) {
+    // Create a random number generator for regalloc randomization.
+    // Use function's sequence and Kind value as the salt.
+    uint64_t Salt =
+        (Func->getSequenceNumber() << 1) ^ (Kind == RAK_Phi ? 0u : 1u);
     Func->getTarget()->makeRandomRegisterPermutation(
-        Permutation, PreDefinedRegisters | ~RegMaskFull);
+        Permutation, PreDefinedRegisters | ~RegMaskFull, Salt);
   }
 
   // Finish up by assigning RegNumTmp->RegNum (or a random permutation
   // thereof) for each Variable.
   for (Variable *Item : Handled) {
     int32_t RegNum = Item->getRegNumTmp();
     int32_t AssignedRegNum = RegNum;
 
     if (Randomized && Item->hasRegTmp() && !Item->hasReg()) {
       AssignedRegNum = Permutation[RegNum];
@@ skipping 57 matching lines @@
     Str << "\n";
   }
   Str << "++++++ Inactive:\n";
   for (const Variable *Item : Inactive) {
     dumpLiveRange(Item, Func);
     Str << "\n";
   }
 }
 
 } // end of namespace Ice