Subzero: Randomize immediates by constant blinding or pooling.

src/IceGlobalContext.cpp

 //===- subzero/src/IceGlobalContext.cpp - 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 defines aspects of the compilation that persist across
 // multiple functions.
 //
 //===----------------------------------------------------------------------===//
 
 #include <ctype.h> // isdigit(), isupper()
 #include <locale>  // locale
 
 #include "IceDefs.h"
 #include "IceTypes.h"
 #include "IceCfg.h"
 #include "IceClFlags.h"
 #include "IceGlobalContext.h"
 #include "IceOperand.h"
 #include "IceTargetLowering.h"
 
 namespace Ice {
 
+namespace {
+
+template <class MapTy, class ListTy>
+ListTy makeListOfValues(const MapTy &Pool) {
+  ListTy Values;
+  Values.reserve(Pool.size());
+  // TODO: replace the loop with std::transform + lambdas.
+  for (typename MapTy::const_iterator I = Pool.begin(), E = Pool.end(); I != E;
+       ++I) {
+    Values.push_back(I->second);
+  }
+  return Values;
+}
+
+} // end of anonymous namespace
+
 // TypePool maps constants of type KeyType (e.g. float) to pointers to
 // type ValueType (e.g. ConstantFloat).  KeyType values are compared
 // using memcmp() because of potential NaN values in KeyType values.
 // KeyTypeHasFP indicates whether KeyType is a floating-point type
 // whose values need to be compared using memcmp() for NaN
 // correctness.  TODO: use std::is_floating_point<KeyType> instead of
 // KeyTypeHasFP with C++11.
 template <typename KeyType, typename ValueType, bool KeyTypeHasFP = false>
 class TypePool {
   TypePool(const TypePool &) LLVM_DELETED_FUNCTION;
   TypePool &operator=(const TypePool &) LLVM_DELETED_FUNCTION;
 
 public:
   TypePool() : NextPoolID(0) {}
   ValueType *getOrAdd(GlobalContext *Ctx, Type Ty, KeyType Key) {
     TupleType TupleKey = std::make_pair(Ty, Key);
     typename ContainerType::const_iterator Iter = Pool.find(TupleKey);
     if (Iter != Pool.end())
       return Iter->second;
     ValueType *Result = ValueType::create(Ctx, Ty, Key, NextPoolID++);
     Pool[TupleKey] = Result;
     return Result;
   }
   ConstantList getConstantPool() const {
-    ConstantList Constants;
-    Constants.reserve(Pool.size());
-    // TODO: replace the loop with std::transform + lambdas.
-    for (typename ContainerType::const_iterator I = Pool.begin(),
-                                                E = Pool.end();
-         I != E; ++I) {
-      Constants.push_back(I->second);
-    }
-    return Constants;
+    return makeListOfValues<ContainerType, ConstantList>(Pool);
   }
 
 private:
   typedef std::pair<Type, KeyType> TupleType;
   struct TupleCompare {
     bool operator()(const TupleType &A, const TupleType &B) const {
       if (A.first != B.first)
         return A.first < B.first;
       if (KeyTypeHasFP)
         return memcmp(&A.second, &B.second, sizeof(KeyType)) < 0;
       return A.second < B.second;
     }
   };
   typedef std::map<const TupleType, ValueType *, TupleCompare> ContainerType;
   ContainerType Pool;
   uint32_t NextPoolID;
 };
 
+// ImmediatePool is used for pooling constants that are typically used
+// as immediate operands but have been pooled for code randomization
+// purposes.  The pool maps strings to constants of any type.  The
+// string is a unique label for a given immediate.
+class ImmediatePool {
+  ImmediatePool(const ImmediatePool &) LLVM_DELETED_FUNCTION;
+  ImmediatePool &operator=(const ImmediatePool &) LLVM_DELETED_FUNCTION;
+
+public:
+  ImmediatePool() {}
+
+  void add(const IceString &Name, Constant *Value) { Pool[Name] = Value; }
+  ConstantList getConstantPool() const {
+    return makeListOfValues<ContainerType, ConstantList>(Pool);
+  }
+
+private:
+  typedef std::map<IceString, Constant *> ContainerType;
+  ContainerType Pool;
+};
+
 // UndefPool maps ICE types to the corresponding ConstantUndef values.
 class UndefPool {
   UndefPool(const UndefPool &) LLVM_DELETED_FUNCTION;
   UndefPool &operator=(const UndefPool &) LLVM_DELETED_FUNCTION;
 
 public:
   UndefPool() : NextPoolID(0) {}
 
   ConstantUndef *getOrAdd(GlobalContext *Ctx, Type Ty) {
     ContainerType::iterator I = Pool.find(Ty);
@@ skipping 15 matching lines @@
 class ConstantPool {
   ConstantPool(const ConstantPool &) LLVM_DELETED_FUNCTION;
   ConstantPool &operator=(const ConstantPool &) LLVM_DELETED_FUNCTION;
 
 public:
   ConstantPool() {}
   TypePool<float, ConstantFloat, true> Floats;
   TypePool<double, ConstantDouble, true> Doubles;
   TypePool<uint64_t, ConstantInteger> Integers;
   TypePool<RelocatableTuple, ConstantRelocatable> Relocatables;
+  ImmediatePool Immediates;
   UndefPool Undefs;
 };
 
 GlobalContext::GlobalContext(llvm::raw_ostream *OsDump,
                              llvm::raw_ostream *OsEmit, VerboseMask Mask,
                              TargetArch Arch, OptLevel Opt,
                              IceString TestPrefix, const ClFlags &Flags)
     : StrDump(OsDump), StrEmit(OsEmit), VMask(Mask),
       ConstPool(new ConstantPool()), Arch(Arch), Opt(Opt),
       TestPrefix(TestPrefix), Flags(Flags), HasEmittedFirstMethod(false),
@@ skipping 212 matching lines @@
     BaseOS << "Unsupported constant type: " << Ty;
     llvm_unreachable(BaseOS.str().c_str());
   } break;
   case IceType_void:
   case IceType_NUM:
     break;
   }
   llvm_unreachable("Unknown type");
 }
 
+void GlobalContext::addConstantPooledImmediate(const IceString &Name,
+                                               Constant *Immediate) {
+  ConstPool->Immediates.add(Name, Immediate);
+}
+
 ConstantList GlobalContext::getConstantPool(Type Ty) const {
   switch (Ty) {
   case IceType_i1:
   case IceType_i8:
   case IceType_i16:
   case IceType_i32:
   case IceType_i64:
     return ConstPool->Integers.getConstantPool();
   case IceType_f32:
     return ConstPool->Floats.getConstantPool();
@@ skipping 11 matching lines @@
     BaseOS << "Unsupported constant type: " << Ty;
     llvm_unreachable(BaseOS.str().c_str());
   } break;
   case IceType_void:
   case IceType_NUM:
     break;
   }
   llvm_unreachable("Unknown type");
 }
 
+ConstantList GlobalContext::getImmediatePool() const {
+  return ConstPool->Immediates.getConstantPool();
+}
+
 void Timer::printElapsedUs(GlobalContext *Ctx, const IceString &Tag) const {
   if (Ctx->isVerbose(IceV_Timing)) {
     // Prefixing with '#' allows timing strings to be included
     // without error in textual assembly output.
     Ctx->getStrDump() << "# " << getElapsedUs() << " usec " << Tag << "\n";
   }
 }
 
 } // end of namespace Ice