Order jump tables for deterministic or randomized emission.

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 860 matching lines @@
   case IceType_NUM:
     break;
   }
   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.
+    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) {
+      return A.getFunctionName() < B.getFunctionName() || A.getId() < B.getId();

[Jim Stichnoth, 2015/08/04 20:22:52]

Is this the right comparison function?

Usually when there is a primary and secondary key, the comparison function looks
like:
  if (A.primary != B.primary)
    return A.primary < B.primary;
  return A.secondary < B.secondary;

[ascull, 2015/08/04 20:36:38]

Done.

+    });
+  }
+  return JumpTables;
+}
+
 JumpTableData &GlobalContext::addJumpTable(IceString FuncName, SizeT Id,
                                            SizeT NumTargets) {
-  auto JumpTables = getJumpTables();
-  JumpTables->emplace_back(FuncName, Id, NumTargets);
-  return JumpTables->back();
+  auto JumpTableList = getJumpTableList();
+  JumpTableList->emplace_back(FuncName, Id, NumTargets);
+  return JumpTableList->back();
 }
 
 TimerStackIdT GlobalContext::newTimerStackID(const IceString &Name) {
   if (!BuildDefs::dump())
     return 0;
   auto Timers = getTimers();
   TimerStackIdT NewID = Timers->size();
   Timers->push_back(TimerStack(Name));
   return NewID;
 }
@@ skipping 96 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