Use separate random number generator for each randomization pass

src/IceGlobalContext.cpp

 //===- subzero/src/IceGlobalContext.cpp - Global context defs -------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 204 matching lines @@
   if (ssize_t MemUsed = llvm::TimeRecord::getCurrentTime(false).getMemUsed())
     Str << MemUsed;
   else
     Str << "(requires '-track-memory')";
   Str << "\n";
 }
 
 GlobalContext::GlobalContext(Ostream *OsDump, Ostream *OsEmit, Ostream *OsError,
                              ELFStreamer *ELFStr, const ClFlags &Flags)
     : ConstPool(new ConstantPool()), ErrorStatus(), StrDump(OsDump),
-      StrEmit(OsEmit), StrError(OsError), Flags(Flags),
-      RNG(Flags.getRandomSeed()), ObjectWriter(),
+      StrEmit(OsEmit), StrError(OsError), Flags(Flags), ObjectWriter(),
       OptQ(/*Sequential=*/Flags.isSequential(),
            /*MaxSize=*/Flags.getNumTranslationThreads()),
       // EmitQ is allowed unlimited size.
       EmitQ(/*Sequential=*/Flags.isSequential()),
       DataLowering(TargetDataLowering::createLowering(this)) {
   assert(OsDump && "OsDump is not defined for GlobalContext");
   assert(OsEmit && "OsEmit is not defined for GlobalContext");
   assert(OsError && "OsError is not defined for GlobalContext");
   // Make sure thread_local fields are properly initialized before any
   // accesses are made.  Do this here instead of at the start of
@@ skipping 29 matching lines @@
   // ensure that at least this' member variables are initialized.
   ProfileBlockInfoVarDecl = VariableDeclaration::create(this);
   ProfileBlockInfoVarDecl->setAlignment(typeWidthInBytes(IceType_i64));
   ProfileBlockInfoVarDecl->setIsConstant(true);
 
   // Note: if you change this symbol, make sure to update
   // runtime/szrt_profiler.c as well.
   ProfileBlockInfoVarDecl->setName("__Sz_block_profile_info");
   ProfileBlockInfoVarDecl->setSuppressMangling();
   ProfileBlockInfoVarDecl->setLinkage(llvm::GlobalValue::ExternalLinkage);
-
-  // Initialize the randomization cookie for constant blinding only if constant
-  // blinding or pooling is turned on.
-  // TODO(stichnot): Using RNG for constant blinding will affect the random
-  // number to be used in nop-insertion and randomize-regalloc.
-  if (Flags.getRandomizeAndPoolImmediatesOption() != RPI_None)
-    RandomizationCookie =
-        (uint32_t)RNG.next((uint64_t)std::numeric_limits<uint32_t>::max + 1);
 }
 
 void GlobalContext::translateFunctions() {
   while (std::unique_ptr<Cfg> Func = optQueueBlockingPop()) {
     // Install Func in TLS for Cfg-specific container allocators.
     Cfg::setCurrentCfg(Func.get());
     // Reset per-function stats being accumulated in TLS.
     resetStats();
     // Set verbose level to none if the current function does NOT
     // match the -verbose-focus command-line option.
@@ skipping 102 matching lines @@
     for (const Ice::VariableDeclaration *Global : Globals) {
       Global->dump(this, Stream);
     }
   }
   if (Flags.getDisableTranslation())
     return;
 
   addBlockInfoPtrs(Globals, ProfileBlockInfoVarDecl);
   // If we need to shuffle the layout of global variables, shuffle them now.
   if (getFlags().shouldReorderGlobalVariables()) {
-    auto *RNGPtr = &RNG;
+    // Create a random number generator for global variable reordering.
+    RandomNumberGenerator RNG(getFlags().getRandomSeed(),
+                              RS_GlobalVariableReordering);
     RandomShuffle(Globals.begin(), Globals.end(),
-                  [RNGPtr](int N) { return (uint32_t)RNGPtr->next(N); });
+                  [&RNG](int N) { return (uint32_t)RNG.next(N); });
   }
   DataLowering->lowerGlobals(Globals, SectionSuffix);
   for (VariableDeclaration *Var : Globals) {
     Var->discardInitializers();
   }
   Globals.clear();
 }
 
 void GlobalContext::lowerProfileData() {
   // ProfileBlockInfoVarDecl is initialized in the constructor, and will only
@@ skipping 20 matching lines @@
   // insert it into Pending and repeat.  The work item is deleted
   // after it is processed.
   std::vector<EmitterWorkItem *> Pending;
   uint32_t DesiredSequenceNumber = getFirstSequenceNumber();
   uint32_t ShuffleStartIndex = DesiredSequenceNumber;
   uint32_t ShuffleEndIndex = DesiredSequenceNumber;
   bool EmitQueueEmpty = false;
   const uint32_t ShuffleWindowSize =
       std::max(1u, getFlags().getReorderFunctionsWindowSize());
   bool Shuffle = Threaded && getFlags().shouldReorderFunctions();
+  // Create a random number generator for function reordering.
+  RandomNumberGenerator RNG(getFlags().getRandomSeed(), RS_FunctionReordering);
+
   while (!EmitQueueEmpty) {
     resizePending(Pending, DesiredSequenceNumber);
     // See if Pending contains DesiredSequenceNumber.
     EmitterWorkItem *RawItem = Pending[DesiredSequenceNumber];
     if (RawItem == nullptr) {
       // We need to fetch an EmitterWorkItem from the queue.
       RawItem = emitQueueBlockingPop();
       if (RawItem == nullptr) {
         // This is the notifier for an empty queue.
         EmitQueueEmpty = true;
@@ skipping 31 matching lines @@
           ShuffleEndIndex - ShuffleStartIndex < ShuffleWindowSize &&
           RawItem->getKind() != EmitterWorkItem::WI_GlobalInits)
         continue;
 
       // Emit the EmitterWorkItem between Pending[ShuffleStartIndex] to
       // Pending[ShuffleEndIndex]. If function reordering turned on, shuffle the
       // pending items from Pending[ShuffleStartIndex] to
       // Pending[ShuffleEndIndex].
       RandomShuffle(Pending.begin() + ShuffleStartIndex,
                     Pending.begin() + ShuffleEndIndex,
-                    [this](uint64_t N) { return (uint32_t)RNG.next(N); });
+                    [&RNG](uint64_t N) { return (uint32_t)RNG.next(N); });
     }
 
     // Emit the item from ShuffleStartIndex to ShuffleEndIndex.
     for (uint32_t I = ShuffleStartIndex; I < ShuffleEndIndex; I++) {
       std::unique_ptr<EmitterWorkItem> Item(Pending[I]);
 
       switch (Item->getKind()) {
       case EmitterWorkItem::WI_Nop:
         break;
       case EmitterWorkItem::WI_GlobalInits: {
@@ skipping 362 matching lines @@
   llvm_unreachable("Unknown type");
 }
 
 ConstantList GlobalContext::getConstantExternSyms() {
   return getConstPool()->ExternRelocatables.getConstantPool();
 }
 
 JumpTableDataList GlobalContext::getJumpTables() {
   JumpTableDataList JumpTables(*getJumpTableList());
   if (getFlags().shouldReorderPooledConstants()) {
-    // If reorder-pooled-constants option is set to true, we need to shuffle the
-    // constant pool before emitting it.
+    // If reorder-pooled-constants option is set to true, we also shuffle the
+    // jump tables before emitting them.
+    // Create a random number generator for jump tables reordering, considering

[Jim Stichnoth, 2015/08/19 19:03:04]

Either reformat this entire comment (to fix weird line break), or add a blank
comment line.

[qining, 2015/08/19 23:25:48]

Done.

+    // jump tables as pooled constants.
+    RandomNumberGenerator RNG(getFlags().getRandomSeed(),
+                              RS_PooledConstantReordering);
     RandomShuffle(JumpTables.begin(), JumpTables.end(),
-                  [this](uint64_t N) { return (uint32_t)getRNG().next(N); });
+                  [&RNG](uint64_t N) { return (uint32_t)RNG.next(N); });
   } else {
     // Make order deterministic by sorting into functions and then ID of the
     // jump table within that function.
     std::sort(JumpTables.begin(), JumpTables.end(),
               [](const JumpTableData &A, const JumpTableData &B) {
                 if (A.getFunctionName() != B.getFunctionName())
                   return A.getFunctionName() < B.getFunctionName();
                 return A.getId() < B.getId();
               });
   }
@@ skipping 114 matching lines @@
   Ctx = Func->getContext();
   Active =
       Func->getFocusedTiming() || Ctx->getFlags().getSubzeroTimingEnabled();
   if (Active)
     Ctx->pushTimer(ID, StackID);
 }
 
 ICE_TLS_DEFINE_FIELD(GlobalContext::ThreadContext *, GlobalContext, TLS);
 
 } // end of namespace Ice