Subzero: Fix floating-point constant pooling.

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.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines aspects of the compilation that persist across
@@ skipping 47 matching lines @@
   }
   ConstantList getConstantPool() const {
     ConstantList Constants;
     Constants.reserve(Pool.size());
     for (auto &I : Pool)
       Constants.push_back(I.second);
     return Constants;
   }
 
 private:
-  typedef std::unordered_map<KeyType, ValueType *> ContainerType;
+  struct compare {
+    bool operator()(const KeyType &Value1, const KeyType &Value2) const {
+      if (std::is_floating_point<KeyType>::value)
+        return !memcmp(&Value1, &Value2, sizeof(KeyType));
+      return std::equal_to<KeyType>()(Value1, Value2);
+    }
+  };
+  typedef std::unordered_map<KeyType, ValueType *, std::hash<KeyType>, compare>
+      ContainerType;

[JF, 2015/03/19 16:33:09]

template<typename T>
struct Compare {
  typename std::enable_if<std::is_integral<T>::value, bool>::type
  operator()(const KeyType &LHS, const KeyType &RHS) const {
    return LHS == RHS;
  }
  typename std::enable_if<std::is_floating_point<T>::value, bool>::type
  operator()(const KeyType &LHS, const KeyType &RHS) const {
    return !memcmp(&RHS, &LHS, sizeof(KeyType));
  }
};
typedef std::unordered_map<KeyType, ValueType *, std::hash<KeyType>,
Compare<KeyType>>
       ContainerType;

[Jim Stichnoth, 2015/03/19 18:07:04]

Cool.  I did it a slightly different way.

It has to handle the RelocatableTuple type as well (which already has a valid ==
operator).  Is there any way to combine that with the is_integral<T> test?

[Jim Stichnoth, 2015/03/19 19:57:49]

Tweaked once more to combine integral types and RelocatableTuple.

   ContainerType Pool;
   uint32_t NextPoolID;
 };
 
 // UndefPool maps ICE types to the corresponding ConstantUndef values.
 class UndefPool {
   UndefPool(const UndefPool &) = delete;
   UndefPool &operator=(const UndefPool &) = delete;
 
 public:
@@ skipping 662 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