Add constant blinding/pooling option for X8632 code translation

src/IceGlobalContext.h

 //===- subzero/src/IceGlobalContext.h - Global context defs -----*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares aspects of the compilation that persist across
@@ skipping 54 matching lines @@
   // CodeStats collects rudimentary statistics during translation.
   class CodeStats {
     CodeStats(const CodeStats &) = delete;
     CodeStats &operator=(const CodeStats &) = default;
 #define CODESTATS_TABLE                                                        \
   /* dump string, enum value */                                                \
   X("Inst Count  ", InstCount)                                                 \
   X("Regs Saved  ", RegsSaved)                                                 \
   X("Frame Bytes ", FrameByte)                                                 \
   X("Spills      ", NumSpills)                                                 \
-  X("Fills       ", NumFills)
+  X("Fills       ", NumFills)                                                  \
+  X("R/P Imms    ", NumRPImms)
     //#define X(str, tag)
 
   public:
     enum CSTag {
 #define X(str, tag) CS_##tag,
       CODESTATS_TABLE
 #undef X
           CS_NUM
     };
     CodeStats() { reset(); }
@@ skipping 170 matching lines @@
     Tls->StatsCumulative.update(CodeStats::CS_NumSpills);
   }
   void statsUpdateFills() {
     if (!getFlags().getDumpStats())
       return;
     ThreadContext *Tls = ICE_TLS_GET_FIELD(TLS);
     Tls->StatsFunction.update(CodeStats::CS_NumFills);
     Tls->StatsCumulative.update(CodeStats::CS_NumFills);
   }
 
+  // Number of Randomized or Pooled Immediates
+  void statsUpdateRPImms() {
+    if (!getFlags().getDumpStats())
+      return;
+    ThreadContext *Tls = ICE_TLS_GET_FIELD(TLS);
+    Tls->StatsFunction.update(CodeStats::CS_NumRPImms);
+    Tls->StatsCumulative.update(CodeStats::CS_NumRPImms);
+  }
+
   // These are predefined TimerStackIdT values.
   enum TimerStackKind { TSK_Default = 0, TSK_Funcs, TSK_Num };
 
   // newTimerStackID() creates a new TimerStack in the global space.
   // It does not affect any TimerStack objects in TLS.
   TimerStackIdT newTimerStackID(const IceString &Name);
   // dumpTimers() dumps the global timer data.  As such, one probably
   // wants to call mergeTimerStacks() as a prerequisite.
   void dumpTimers(TimerStackIdT StackID = TSK_Default,
                   bool DumpCumulative = true);
@@ skipping 108 matching lines @@
   // This is used in a few cases where we want to take some action on
   // a particular function or symbol based on a command-line argument,
   // such as changing the verbose level for a particular function.  An
   // empty Match argument means match everything.  Returns true if
   // there is a match.
   static bool matchSymbolName(const IceString &SymbolName,
                               const IceString &Match) {
     return Match.empty() || Match == SymbolName;
   }
 
+  // Return the randomization cookie for diversification.
+  // Initialize the cookie if necessary
+  uint32_t getRandomizationCookie() {
+    if (RandomizationCookie != 0)
+      return RandomizationCookie;
+    RandomizationCookieLock.lock();

[Jim Stichnoth, 2015/06/19 16:51:02]

You should use the std::unique_lock<> pattern (see other uses in Subzero) when
possible, rather than explicit lock()/unlock().

But to echo JF's point, you need to lock reads as well, which means moving the
lock(), or the unique_lock<>, to the beginning of the method.  But means tons of
extra lock operations, which you were clearly trying to avoid.

For now, I think you can just make RandomizationCookie a const field and pass it
into the ctor.  I.e., make the RNG.next() calls before GlobalContext is created.

In the future, we will probably want to hold this in the Cfg or TargetLowering
object.

+    while (RandomizationCookie == 0) {
+      RandomNumberGenerator &RNG = getRNG();
+      RandomizationCookie = (uint32_t)RNG.next(
+          (uint64_t)std::numeric_limits<uint32_t>::max() + 1);
+    }
+    RandomizationCookieLock.unlock();
+    return RandomizationCookie;
+  }
+
 private:
   // Try to ensure mutexes are allocated on separate cache lines.
 
   ICE_CACHELINE_BOUNDARY;
   // Managed by getAllocator()
   GlobalLockType AllocLock;
   ArenaAllocator<> Allocator;
 
   ICE_CACHELINE_BOUNDARY;
   // Managed by getConstantPool()
@@ skipping 49 matching lines @@
   llvm::SmallVector<std::thread, 128> TranslationThreads;
   llvm::SmallVector<std::thread, 128> EmitterThreads;
   // Each thread has its own TLS pointer which is also held in
   // AllThreadContexts.
   ICE_TLS_DECLARE_FIELD(ThreadContext *, TLS);
 
   // Private helpers for mangleName()
   typedef llvm::SmallVector<char, 32> ManglerVector;
   void incrementSubstitutions(ManglerVector &OldName) const;
 
+  // Randomization Cookie
+  // Managed by getRandomizationCookie()
+  GlobalLockType RandomizationCookieLock;
+  uint32_t RandomizationCookie;
+
 public:
   static void TlsInit() { ICE_TLS_INIT_FIELD(TLS); }
 };
 
 // Helper class to push and pop a timer marker.  The constructor
 // pushes a marker, and the destructor pops it.  This is for
 // convenient timing of regions of code.
 class TimerMarker {
   TimerMarker() = delete;
   TimerMarker(const TimerMarker &) = delete;
@@ skipping 40 matching lines @@
   explicit OstreamLocker(GlobalContext *Ctx) : Ctx(Ctx) { Ctx->lockStr(); }
   ~OstreamLocker() { Ctx->unlockStr(); }
 
 private:
   GlobalContext *const Ctx;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEGLOBALCONTEXT_H