Subzero: Simplify the constant pools.

src/IceOperand.cpp

 //===- subzero/src/IceOperand.cpp - High-level operand implementation -----===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the Operand class and its target-independent
 // subclasses, primarily for the methods of the Variable class.
 //
 //===----------------------------------------------------------------------===//
 
 #include "IceCfg.h"
 #include "IceCfgNode.h"
 #include "IceInst.h"
 #include "IceOperand.h"
 #include "IceTargetLowering.h" // dumping stack/frame pointer register
 
 namespace Ice {
 
-bool operator<(const RelocatableTuple &A, const RelocatableTuple &B) {
-  if (A.Offset != B.Offset)
-    return A.Offset < B.Offset;
-  if (A.SuppressMangling != B.SuppressMangling)
-    return A.SuppressMangling < B.SuppressMangling;
-  return A.Name < B.Name;
+bool operator==(const RelocatableTuple &A, const RelocatableTuple &B) {
+  return A.Offset == B.Offset && A.Name == B.Name;

[jvoung (off chromium), 2014/11/19 20:54:55]

This used to check SuppressMangling as well. It does seem like there shouldn't
be a conflict w/ not checking that, so should be okay, but just wanted to check.
Same with the hash function.

[Jim Stichnoth, 2014/11/20 00:08:57]

You're right, I'll update the commit message.

We will never have two (relocatable) symbols with the same name where one
version needs mangling and the other version does not.  The ones that need
mangling are globals with definitions/initializations in this pexe.  The ones
that don't need mangling are helper functions, and external globals without
definitions/initializations.  So there's no benefit to including the
SuppressMangling field in the tuple comparison and hash functions.  The fact
that we used it before was either always unnecessary, or covering over some
other misunderstanding or incorrect implementation.

 }
 
 bool operator<(const RegWeight &A, const RegWeight &B) {
   return A.getWeight() < B.getWeight();
 }
 bool operator<=(const RegWeight &A, const RegWeight &B) { return !(B < A); }
 bool operator==(const RegWeight &A, const RegWeight &B) {
   return !(B < A) && !(A < B);
 }
 
@@ skipping 481 matching lines @@
   if (!ALLOW_DUMP)
     return Str;
   if (W.getWeight() == RegWeight::Inf)
     Str << "Inf";
   else
     Str << W.getWeight();
   return Str;
 }
 
 } // end of namespace Ice