Subzero: Simplify the constant pools.

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 151 matching lines @@
     return Operand->getKind() == K;
   }
 
 private:
   ConstantPrimitive(Type Ty, T Value, uint32_t PoolEntryID)
       : Constant(K, Ty, PoolEntryID), Value(Value) {}
   ~ConstantPrimitive() override {}
   const T Value;
 };
 
-typedef ConstantPrimitive<uint32_t, Operand::kConstInteger32> ConstantInteger32;
-typedef ConstantPrimitive<uint64_t, Operand::kConstInteger64> ConstantInteger64;
+typedef ConstantPrimitive<int32_t, Operand::kConstInteger32> ConstantInteger32;
+typedef ConstantPrimitive<int64_t, Operand::kConstInteger64> ConstantInteger64;
 typedef ConstantPrimitive<float, Operand::kConstFloat> ConstantFloat;
 typedef ConstantPrimitive<double, Operand::kConstDouble> ConstantDouble;
 
 template <> inline void ConstantInteger32::dump(const Cfg *, Ostream &Str) const {
   if (!ALLOW_DUMP)
     return;
   if (getType() == IceType_i1)
     Str << (getValue() ? "true" : "false");
   else
     Str << static_cast<int32_t>(getValue());
 }
 
 template <> inline void ConstantInteger64::dump(const Cfg *, Ostream &Str) const {
   if (!ALLOW_DUMP)
     return;
   assert(getType() == IceType_i64);
   Str << static_cast<int64_t>(getValue());
 }
 
 // RelocatableTuple bundles the parameters that are used to
 // construct an ConstantRelocatable.  It is done this way so that
 // ConstantRelocatable can fit into the global constant pool
 // template mechanism.
 class RelocatableTuple {
-  // RelocatableTuple(const RelocatableTuple &) = delete;
   RelocatableTuple &operator=(const RelocatableTuple &) = delete;
 
 public:
   RelocatableTuple(const RelocOffsetT Offset, const IceString &Name,
                    bool SuppressMangling)
       : Offset(Offset), Name(Name), SuppressMangling(SuppressMangling) {}
+  RelocatableTuple(const RelocatableTuple &) = default;
 
   const RelocOffsetT Offset;
   const IceString Name;
   bool SuppressMangling;
 };
 
-bool operator<(const RelocatableTuple &A, const RelocatableTuple &B);
+bool operator==(const RelocatableTuple &A, const RelocatableTuple &B);
 
 // ConstantRelocatable represents a symbolic constant combined with
 // a fixed offset.
 class ConstantRelocatable : public Constant {
   ConstantRelocatable(const ConstantRelocatable &) = delete;
   ConstantRelocatable &operator=(const ConstantRelocatable &) = delete;
 
 public:
   static ConstantRelocatable *create(GlobalContext *Ctx, Type Ty,
                                      const RelocatableTuple &Tuple,
@@ skipping 413 matching lines @@
 private:
   const Cfg *Func;
   MetadataKind Kind;
   std::vector<VariableTracking> Metadata;
   const static InstDefList NoDefinitions;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H