Use separate random number generator for each randomization pass

src/IceGlobalContext.cpp

Index: src/IceGlobalContext.cpp
diff --git a/src/IceGlobalContext.cpp b/src/IceGlobalContext.cpp
index ffa6c15bd024a8dbaf8372c3dba0e7457058640e..3d157652cd8e8f8e44e1adcb4e3e6ebf59b1c49d 100644
--- a/src/IceGlobalContext.cpp
+++ b/src/IceGlobalContext.cpp
@@ -222,8 +222,7 @@ void GlobalContext::CodeStats::dump(const IceString &Name, Ostream &Str) {
 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(),

[Jim Stichnoth, 2015/08/20 04:04:41]

A few points regarding ClFlags::RandomSeed.  (These could probably be addressed
in a separate CL.)

1. We do need some way to set RandomSeed to something like time(0).  Maybe a
special value like -sz-seed=0 or -sz-seed=-1 would do that.

2. For the browser build of Subzero, we would probably make time(0) the default.
 We definitely don't want to add more flags to the browser interface.

3. When setting the seed to time(0), we need to make it possible to discover
what that value of time(0) was, so that we can debug and reproduce failures:

(a) Print it to StrDump.

(b) Add it to the global initializer list as a hidden/internal symbol.

(c) Get it logged somehow in the browser build.

Jan, do you have any thoughts on this, especially the browser side?

[jvoung (off chromium), 2015/08/20 12:41:04]

I need to look at the rest of the CL, but BrowserCompileServer::getParsedFlags
initializes the ClFlags specially for the browser (e.g., default to --sandbox,
and ELF output). That could be a place to initialize the seed without needing to
plumb anything from the chrome renderer.
Hmm, at least if you run chrome from the terminal it should show up in the
terminal
(https://developer.chrome.com/native-client/devguide/devcycle/debugging#using-...).
So, (a) could then help developers... No user would run chrome that way though
=).  Unfortunately we don't have a nicer way to pipe stdout to the JS console
automatically (I think Mark advocated for that, but there was some pushback
about feature creep from the pepper folks a while back...).

For (b), you mean so that someone can look in the browser cache for the
resulting nexe, and attach that to a bug report or if there is automatic crash
reporting which attached parts of the nexe? Then we can inspect that nexe (parts
of it)? That could be interesting. You might also be able to do something with
ELF like add a NOTE section, kind of like .note.gnu.build-id, but
.note.sz.random-seed or something.

For (c), yeah... (a) is about the closest you can get. You could add something
to the private IRT interface for just subzero, and plumb that out to the browser
after compilation finishes, then push that to the JS console or wherever you
like. We currently only plumb crash messages from StrError and
report_fatal_error(), but that is only if Subzero itself crashes, not if the app
crashes.

[qining, 2015/08/20 16:19:33]

I guess this would be a separate CL?

+      StrEmit(OsEmit), StrError(OsError), Flags(Flags), ObjectWriter(),
       OptQ(/*Sequential=*/Flags.isSequential(),
            /*MaxSize=*/Flags.getNumTranslationThreads()),
       // EmitQ is allowed unlimited size.
@@ -273,14 +272,6 @@ GlobalContext::GlobalContext(Ostream *OsDump, Ostream *OsEmit, Ostream *OsError,
   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() {
@@ -403,9 +394,11 @@ void GlobalContext::lowerGlobals(const IceString &SectionSuffix) {
   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(),
+                              RPE_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) {
@@ -446,6 +439,9 @@ void GlobalContext::emitItems() {
   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(), RPE_FunctionReordering);
+
   while (!EmitQueueEmpty) {
     resizePending(Pending, DesiredSequenceNumber);
     // See if Pending contains DesiredSequenceNumber.
@@ -497,7 +493,7 @@ void GlobalContext::emitItems() {
       // 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.
@@ -879,20 +875,25 @@ ConstantList GlobalContext::getConstantExternSyms() {
 
 JumpTableDataList GlobalContext::getJumpTables() {
   JumpTableDataList JumpTables(*getJumpTableList());
+  // 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();
+            });
+
   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
+    // jump tables as pooled constants.
+    RandomNumberGenerator RNG(getFlags().getRandomSeed(),
+                              RPE_PooledConstantReordering);
     RandomShuffle(JumpTables.begin(), JumpTables.end(),
-                  [this](uint64_t N) { return (uint32_t)getRNG().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();
-              });
+                  [&RNG](uint64_t N) { return (uint32_t)RNG.next(N); });
   }
   return JumpTables;
 }