Subzero: Fix x86 floating-point constant emission

src/IceOperand.h

 //===- subzero/src/IceOperand.h - High-level operands -----------*- 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 the Operand class and its target-independent
@@ skipping 62 matching lines @@
 
 private:
   Operand(const Operand &) LLVM_DELETED_FUNCTION;
   Operand &operator=(const Operand &) LLVM_DELETED_FUNCTION;
 };
 
 // Constant is the abstract base class for constants.  All
 // constants are allocated from a global arena and are pooled.
 class Constant : public Operand {
 public:
+  uint32_t getPoolEntryID() const { return PoolEntryID; }
   virtual void emit(const Cfg *Func) const = 0;
   virtual void dump(const Cfg *Func) const = 0;
 
   static bool classof(const Operand *Operand) {
     OperandKind Kind = Operand->getKind();
     return Kind >= kConst_Base && Kind <= kConst_Num;
   }
 
 protected:
-  Constant(OperandKind Kind, Type Ty) : Operand(Kind, Ty) {
+  Constant(OperandKind Kind, Type Ty, uint32_t PoolEntryID)
+      : Operand(Kind, Ty), PoolEntryID(PoolEntryID) {
     Vars = NULL;
     NumVars = 0;
   }
   virtual ~Constant() {}
+  // PoolEntryID is an integer that uniquely identifies the constant
+  // within its constant pool.  It is used for building the constant
+  // pool in the object code and for referencing its entries.
+  const uint32_t PoolEntryID;
 
 private:
   Constant(const Constant &) LLVM_DELETED_FUNCTION;
   Constant &operator=(const Constant &) LLVM_DELETED_FUNCTION;
 };
 
 // ConstantPrimitive<> wraps a primitive type.
 template <typename T, Operand::OperandKind K>
 class ConstantPrimitive : public Constant {
 public:
-  static ConstantPrimitive *create(GlobalContext *Ctx, Type Ty, T Value) {
+  static ConstantPrimitive *create(GlobalContext *Ctx, Type Ty, T Value,
+                                   uint32_t PoolEntryID) {
     return new (Ctx->allocate<ConstantPrimitive>())
-        ConstantPrimitive(Ty, Value);
+        ConstantPrimitive(Ty, Value, PoolEntryID);
   }
   T getValue() const { return Value; }
   virtual void emit(const Cfg *Func) const {
     Ostream &Str = Func->getContext()->getStrEmit();
     Str << getValue();
   }
   virtual void dump(const Cfg *Func) const {
     Ostream &Str = Func->getContext()->getStrDump();
     Str << getValue();
   }
 
   static bool classof(const Operand *Operand) {
     return Operand->getKind() == K;
   }
 
 private:
-  ConstantPrimitive(Type Ty, T Value) : Constant(K, Ty), Value(Value) {}
+  ConstantPrimitive(Type Ty, T Value, uint32_t PoolEntryID)
+      : Constant(K, Ty, PoolEntryID), Value(Value) {}
   ConstantPrimitive(const ConstantPrimitive &) LLVM_DELETED_FUNCTION;
   ConstantPrimitive &operator=(const ConstantPrimitive &) LLVM_DELETED_FUNCTION;
   virtual ~ConstantPrimitive() {}
   const T Value;
 };
 
 typedef ConstantPrimitive<uint64_t, Operand::kConstInteger> ConstantInteger;
 typedef ConstantPrimitive<float, Operand::kConstFloat> ConstantFloat;
 typedef ConstantPrimitive<double, Operand::kConstDouble> ConstantDouble;
 
@@ skipping 17 matching lines @@
   bool SuppressMangling;
 };
 
 bool operator<(const RelocatableTuple &A, const RelocatableTuple &B);
 
 // ConstantRelocatable represents a symbolic constant combined with
 // a fixed offset.
 class ConstantRelocatable : public Constant {
 public:
   static ConstantRelocatable *create(GlobalContext *Ctx, Type Ty,
-                                     const RelocatableTuple &Tuple) {
+                                     const RelocatableTuple &Tuple,
+                                     uint32_t PoolEntryID) {
     return new (Ctx->allocate<ConstantRelocatable>()) ConstantRelocatable(
-        Ty, Tuple.Offset, Tuple.Name, Tuple.SuppressMangling);
+        Ty, Tuple.Offset, Tuple.Name, Tuple.SuppressMangling, PoolEntryID);
   }
   int64_t getOffset() const { return Offset; }
   IceString getName() const { return Name; }
   void setSuppressMangling(bool Value) { SuppressMangling = Value; }
   bool getSuppressMangling() const { return SuppressMangling; }
   virtual void emit(const Cfg *Func) const;
   virtual void dump(const Cfg *Func) const;
 
   static bool classof(const Operand *Operand) {
     OperandKind Kind = Operand->getKind();
     return Kind == kConstRelocatable;
   }
 
 private:
   ConstantRelocatable(Type Ty, int64_t Offset, const IceString &Name,
-                      bool SuppressMangling)
-      : Constant(kConstRelocatable, Ty), Offset(Offset), Name(Name),
-        SuppressMangling(SuppressMangling) {}
+                      bool SuppressMangling, uint32_t PoolEntryID)
+      : Constant(kConstRelocatable, Ty, PoolEntryID), Offset(Offset),
+        Name(Name), SuppressMangling(SuppressMangling) {}
   ConstantRelocatable(const ConstantRelocatable &) LLVM_DELETED_FUNCTION;
   ConstantRelocatable &
   operator=(const ConstantRelocatable &) LLVM_DELETED_FUNCTION;
   virtual ~ConstantRelocatable() {}
   const int64_t Offset; // fixed offset to add
   const IceString Name; // optional for debug/dump
   bool SuppressMangling;
 };
 
 // RegWeight is a wrapper for a uint32_t weight value, with a
@@ skipping 151 matching lines @@
   Variable *LoVar;
   Variable *HiVar;
   // VarsReal (and Operand::Vars) are set up such that Vars[0] ==
   // this.
   Variable *VarsReal[1];
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H