Subzero: Fix x86 floating-point constant emission

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
@@ skipping 16 matching lines @@
 // 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() {}
+  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);
+    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;
+  }
 
 private:
   typedef std::pair<Type, KeyType> TupleType;
   struct TupleCompare {
     bool operator()(const TupleType &A, const TupleType &B) {
       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;
 };
 
 // The global constant pool bundles individual pools of each type of
 // interest.
 class ConstantPool {
   ConstantPool(const ConstantPool &) LLVM_DELETED_FUNCTION;
   ConstantPool &operator=(const ConstantPool &) LLVM_DELETED_FUNCTION;
 
 public:
   ConstantPool() {}
@@ skipping 93 matching lines @@
   return ConstPool->Doubles.getOrAdd(this, IceType_f64, ConstantDouble);
 }
 
 Constant *GlobalContext::getConstantSym(Type Ty, int64_t Offset,
                                         const IceString &Name,
                                         bool SuppressMangling) {
   return ConstPool->Relocatables.getOrAdd(
       this, Ty, RelocatableTuple(Offset, Name, SuppressMangling));
 }
 
+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();
+  case IceType_f64:
+    return ConstPool->Doubles.getConstantPool();
+  case IceType_void:
+  case IceType_NUM:
+    break;
+  }
+  llvm_unreachable("Unknown type");
+}
+
 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