Subzero: Fix nondeterministic behavior in constant pool creation.

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.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file declares the Operand class and its target-independent subclasses.
 /// The main classes are Variable, which represents an LLVM variable that is
 /// either register- or stack-allocated, and the Constant hierarchy, which
 /// represents integer, floating-point, and/or symbolic constants.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICEOPERAND_H
 #define SUBZERO_SRC_ICEOPERAND_H
 
 #include "IceCfg.h"
 #include "IceDefs.h"
 #include "IceGlobalContext.h"
 #include "IceTypes.h"
 
+#include "llvm/Support/Format.h"
+
 namespace Ice {
 
 class Operand {
   Operand() = delete;
   Operand(const Operand &) = delete;
   Operand &operator=(const Operand &) = delete;
 
 public:
   static constexpr size_t MaxTargetKinds = 10;
   enum OperandKind {
@@ skipping 72 matching lines @@
 }
 
 /// Constant is the abstract base class for constants. All constants are
 /// allocated from a global arena and are pooled.
 class Constant : public Operand {
   Constant() = delete;
   Constant(const Constant &) = delete;
   Constant &operator=(const Constant &) = delete;
 
 public:
-  void emitPoolLabel(Ostream &Str) const {
-    Str << ".L$" << getType() << "$" << PoolEntryID;
-  }
+  virtual void emitPoolLabel(Ostream &Str, const GlobalContext *Ctx) const {
+    (void)Str;
+    (void)Ctx;
+    llvm::report_fatal_error("emitPoolLabel not defined for type");
+  };
   void emit(const Cfg *Func) const override { emit(Func->getTarget()); }
   virtual void emit(TargetLowering *Target) const = 0;
 
   static bool classof(const Operand *Operand) {
     OperandKind Kind = Operand->getKind();
     return Kind >= kConst_Base && Kind <= kConst_Max;
   }
 
   /// Judge if this given immediate should be randomized or pooled By default
   /// should return false, only constant integers should truly go through this
   /// method.
   virtual bool shouldBeRandomizedOrPooled(const GlobalContext *Ctx) {
     (void)Ctx;
     return false;
   }
 
   void setShouldBePooled(bool R) { shouldBePooled = R; }
 
   bool getShouldBePooled() const { return shouldBePooled; }
 
 protected:
-  Constant(OperandKind Kind, Type Ty, uint32_t PoolEntryID)
-      : Operand(Kind, Ty), PoolEntryID(PoolEntryID), shouldBePooled(false) {
+  Constant(OperandKind Kind, Type Ty)
+      : Operand(Kind, Ty), shouldBePooled(false) {
     Vars = nullptr;
     NumVars = 0;
   }
-  /// 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;
   /// Whether we should pool this constant. Usually Float/Double and pooled
   /// Integers should be flagged true.
   bool shouldBePooled;
 };
 
 /// ConstantPrimitive<> wraps a primitive type.
 template <typename T, Operand::OperandKind K>
 class ConstantPrimitive : public Constant {
   ConstantPrimitive() = delete;
   ConstantPrimitive(const ConstantPrimitive &) = delete;
   ConstantPrimitive &operator=(const ConstantPrimitive &) = delete;
 
 public:
   using PrimType = T;
 
-  static ConstantPrimitive *create(GlobalContext *Ctx, Type Ty, PrimType Value,
-                                   uint32_t PoolEntryID) {
+  static ConstantPrimitive *create(GlobalContext *Ctx, Type Ty,
+                                   PrimType Value) {
     assert(!Ctx->isIRGenerationDisabled() &&
            "Attempt to build primitive constant when IR generation disabled");
     return new (Ctx->allocate<ConstantPrimitive>())
-        ConstantPrimitive(Ty, Value, PoolEntryID);
+        ConstantPrimitive(Ty, Value);
   }
   PrimType getValue() const { return Value; }
+  void emitPoolLabel(Ostream &Str, const GlobalContext *Ctx) const final {
+    Str << ".L$" << getType() << "$";
+    // Print hex characters byte by byte, starting from the most significant
+    // byte.  NOTE: This ordering assumes Subzero runs on a little-endian
+    // platform.  That means the possibility of different label names depending
+    // on the endian-ness of the platform where Subzero runs.
+    for (unsigned i = 0; i < sizeof(Value); ++i) {
+      constexpr unsigned HexWidthChars = 2;
+      unsigned Offset = sizeof(Value) - 1 - i;
+      Str << llvm::format_hex_no_prefix(
+          *(Offset + (const unsigned char *)&Value), HexWidthChars);
+    }
+    // For a floating-point value in DecorateAsm mode, also append the value in
+    // human-readable sprintf form, changing '+' to 'p' and '-' to 'm' to
+    // maintain valid asm labels.
+    if (std::is_floating_point<PrimType>::value && !BuildDefs::minimal() &&
+        Ctx->getFlags().getDecorateAsm()) {
+      char Buf[30];
+      snprintf(Buf, llvm::array_lengthof(Buf), "$%g", (double)Value);
+      for (unsigned i = 0; i < llvm::array_lengthof(Buf) && Buf[i]; ++i) {
+        if (Buf[i] == '-')
+          Buf[i] = 'm';
+        else if (Buf[i] == '+')
+          Buf[i] = 'p';
+      }
+      Str << Buf;
+    }
+  }
   using Constant::emit;
   void emit(TargetLowering *Target) const final;
   using Constant::dump;
   void dump(const Cfg *, Ostream &Str) const override {
     if (BuildDefs::dump())
       Str << getValue();
   }
 
   static bool classof(const Operand *Operand) {
     return Operand->getKind() == K;
   }
 
   virtual bool shouldBeRandomizedOrPooled(const GlobalContext *Ctx) override {
     (void)Ctx;
     return false;
   }
 
 private:
-  ConstantPrimitive(Type Ty, PrimType Value, uint32_t PoolEntryID)
-      : Constant(K, Ty, PoolEntryID), Value(Value) {}
+  ConstantPrimitive(Type Ty, PrimType Value) : Constant(K, Ty), Value(Value) {}
   const PrimType Value;
 };
 
 using ConstantInteger32 = ConstantPrimitive<int32_t, Operand::kConstInteger32>;
 using ConstantInteger64 = ConstantPrimitive<int64_t, Operand::kConstInteger64>;
 using ConstantFloat = ConstantPrimitive<float, Operand::kConstFloat>;
 using ConstantDouble = ConstantPrimitive<double, Operand::kConstDouble>;
 
 template <>
 inline void ConstantInteger32::dump(const Cfg *, Ostream &Str) const {
@@ skipping 39 matching lines @@
 
 /// ConstantRelocatable represents a symbolic constant combined with a fixed
 /// offset.
 class ConstantRelocatable : public Constant {
   ConstantRelocatable() = delete;
   ConstantRelocatable(const ConstantRelocatable &) = delete;
   ConstantRelocatable &operator=(const ConstantRelocatable &) = delete;
 
 public:
   static ConstantRelocatable *create(GlobalContext *Ctx, Type Ty,
-                                     const RelocatableTuple &Tuple,
-                                     uint32_t PoolEntryID) {
+                                     const RelocatableTuple &Tuple) {
     assert(!Ctx->isIRGenerationDisabled() &&
            "Attempt to build relocatable constant when IR generation disabled");
     return new (Ctx->allocate<ConstantRelocatable>()) ConstantRelocatable(
-        Ty, Tuple.Offset, Tuple.Name, Tuple.SuppressMangling, PoolEntryID);
+        Ty, Tuple.Offset, Tuple.Name, Tuple.SuppressMangling);
   }
 
   RelocOffsetT getOffset() const { return Offset; }
   const IceString &getName() const { return Name; }
   void setSuppressMangling(bool Value) { SuppressMangling = Value; }
   bool getSuppressMangling() const { return SuppressMangling; }
   using Constant::emit;
   void emit(TargetLowering *Target) const final;
   void emitWithoutPrefix(TargetLowering *Target) const;
   using Constant::dump;
   void dump(const Cfg *Func, Ostream &Str) const override;
 
   static bool classof(const Operand *Operand) {
     OperandKind Kind = Operand->getKind();
     return Kind == kConstRelocatable;
   }
 
 private:
   ConstantRelocatable(Type Ty, RelocOffsetT Offset, const IceString &Name,
-                      bool SuppressMangling, uint32_t PoolEntryID)
-      : Constant(kConstRelocatable, Ty, PoolEntryID), Offset(Offset),
-        Name(Name), SuppressMangling(SuppressMangling) {}
+                      bool SuppressMangling)
+      : Constant(kConstRelocatable, Ty), Offset(Offset), Name(Name),
+        SuppressMangling(SuppressMangling) {}
   const RelocOffsetT Offset; /// fixed offset to add
   const IceString Name;      /// optional for debug/dump
   bool SuppressMangling;
 };
 
 /// ConstantUndef represents an unspecified bit pattern. Although it is legal to
 /// lower ConstantUndef to any value, backends should try to make code
 /// generation deterministic by lowering ConstantUndefs to 0.
 class ConstantUndef : public Constant {
   ConstantUndef() = delete;
   ConstantUndef(const ConstantUndef &) = delete;
   ConstantUndef &operator=(const ConstantUndef &) = delete;
 
 public:
-  static ConstantUndef *create(GlobalContext *Ctx, Type Ty,
-                               uint32_t PoolEntryID) {
+  static ConstantUndef *create(GlobalContext *Ctx, Type Ty) {
     assert(!Ctx->isIRGenerationDisabled() &&
            "Attempt to build undefined constant when IR generation disabled");
-    return new (Ctx->allocate<ConstantUndef>()) ConstantUndef(Ty, PoolEntryID);
+    return new (Ctx->allocate<ConstantUndef>()) ConstantUndef(Ty);
   }
 
   using Constant::emit;
   void emit(TargetLowering *Target) const final;
   using Constant::dump;
   void dump(const Cfg *, Ostream &Str) const override {
     if (BuildDefs::dump())
       Str << "undef";
   }
 
   static bool classof(const Operand *Operand) {
     return Operand->getKind() == kConstUndef;
   }
 
 private:
-  ConstantUndef(Type Ty, uint32_t PoolEntryID)
-      : Constant(kConstUndef, Ty, PoolEntryID) {}
+  ConstantUndef(Type Ty) : Constant(kConstUndef, Ty) {}
 };
 
 /// RegWeight is a wrapper for a uint32_t weight value, with a special value
 /// that represents infinite weight, and an addWeight() method that ensures that
 /// W+infinity=infinity.
 class RegWeight {
 public:
   RegWeight() = default;
   explicit RegWeight(uint32_t Weight) : Weight(Weight) {}
   RegWeight(const RegWeight &) = default;
@@ skipping 383 matching lines @@
 private:
   const Cfg *Func;
   MetadataKind Kind;
   CfgVector<VariableTracking> Metadata;
   const static InstDefList NoDefinitions;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H