Subzero: Fix nondeterministic behavior in constant pool creation.

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 112 matching lines @@
 template <Type Ty, typename KeyType, typename ValueType> class TypePool {
   TypePool(const TypePool &) = delete;
   TypePool &operator=(const TypePool &) = delete;
 
 public:
   TypePool() = default;
   ValueType *getOrAdd(GlobalContext *Ctx, KeyType Key) {
     auto Iter = Pool.find(Key);
     if (Iter != Pool.end())
       return Iter->second;
-    ValueType *Result = ValueType::create(Ctx, Ty, Key, NextPoolID++);
+    ValueType *Result = ValueType::create(Ctx, Ty, Key);
     Pool[Key] = Result;
     return Result;
   }
   ConstantList getConstantPool() const {
     ConstantList Constants;
     Constants.reserve(Pool.size());
     for (auto &I : Pool)
       Constants.push_back(I.second);
     // The sort (and its KeyCompareLess machinery) is not strictly necessary,
     // but is desirable for producing output that is deterministic across
     // unordered_map::iterator implementations.
     std::sort(Constants.begin(), Constants.end(), KeyCompareLess<ValueType>());
     return Constants;
   }
 
 private:
   // Use the default hash function, and a custom key comparison function. The
   // key comparison function for floating point variables can't use the default
   // == based implementation because of special C++ semantics regarding +0.0,
   // -0.0, and NaN comparison. However, it's OK to use the default hash for
   // floating point values because KeyCompare is the final source of truth - in
   // the worst case a "false" collision must be resolved.
   using ContainerType =
       std::unordered_map<KeyType, ValueType *, std::hash<KeyType>,
                          KeyCompare<KeyType>>;
   ContainerType Pool;
-  uint32_t NextPoolID = 0;
 };
 
 // UndefPool maps ICE types to the corresponding ConstantUndef values.
 class UndefPool {
   UndefPool(const UndefPool &) = delete;
   UndefPool &operator=(const UndefPool &) = delete;
 
 public:
   UndefPool() : Pool(IceType_NUM) {}
 
   ConstantUndef *getOrAdd(GlobalContext *Ctx, Type Ty) {
     if (Pool[Ty] == nullptr)
-      Pool[Ty] = ConstantUndef::create(Ctx, Ty, NextPoolID++);
+      Pool[Ty] = ConstantUndef::create(Ctx, Ty);
     return Pool[Ty];
   }
 
 private:
-  uint32_t NextPoolID = 0;
   std::vector<ConstantUndef *> Pool;
 };
 
 } // end of anonymous namespace
 
 // The global constant pool bundles individual pools of each type of
 // interest.
 class ConstantPool {
   ConstantPool(const ConstantPool &) = delete;
   ConstantPool &operator=(const ConstantPool &) = delete;
@@ skipping 818 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