Selectively invert ICMP operands for better address optimization

src/IceInst.def

 //===- subzero/src/IceInst.def - X-macros for ICE instructions  -*- 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 properties of ICE instructions in the form of x-macros.
@@ skipping 70 matching lines @@
   X(Ugt,         "ugt")              \
   X(Uge,         "uge")              \
   X(Ult,         "ult")              \
   X(Ule,         "ule")              \
   X(Une,         "une")              \
   X(Uno,         "uno")              \
   X(True,        "true")
 //#define X(tag, str)
 
 #define ICEINSTICMP_TABLE            \
-  /* enum value, printable string */ \
-  X(Eq,          "eq")               \
-  X(Ne,          "ne")               \
-  X(Ugt,         "ugt")              \
-  X(Uge,         "uge")              \
-  X(Ult,         "ult")              \
-  X(Ule,         "ule")              \
-  X(Sgt,         "sgt")              \
-  X(Sge,         "sge")              \
-  X(Slt,         "slt")              \
-  X(Sle,         "sle")
-//#define X(tag, str)
+  /* enum value, inverse,  printable string */ \

[John, 2016/07/08 18:21:08]

this is not the inverse of the condition... I would probably use "invert" or
something else..

[Jim Stichnoth, 2016/07/10 13:25:32]

Yeah, I think I would agree.

My suggestion now is to call it "reverse", everywhere it was previous called
"inverse" or "invert".

Also, very minor nit.  Put only a single space after the comma in the comment -
multiple spaces are for when you want to align the comment fields with the
actual macro fields below.

Along those lines, slightly bigger nit.  Make the line-ending backslash
characters line up.  Since you're touching this file, you could also change all
backslash lines to put the backslash in column 80 like clang-format does,
instead of the weird indentation that emacs originally chose.

[manasijm, 2016/07/11 22:27:04]

Done.

+  X(Eq,     InstIcmp::ICond::Eq,     "eq")               \
+  X(Ne,     InstIcmp::ICond::Ne,     "ne")               \
+  X(Ugt,    InstIcmp::ICond::Ult,    "ugt")              \
+  X(Uge,    InstIcmp::ICond::Ule,    "uge")              \
+  X(Ult,    InstIcmp::ICond::Ugt,    "ult")              \
+  X(Ule,    InstIcmp::ICond::Uge,    "ule")              \
+  X(Sgt,    InstIcmp::ICond::Slt,    "sgt")              \
+  X(Sge,    InstIcmp::ICond::Sle,    "sge")              \
+  X(Slt,    InstIcmp::ICond::Sgt,    "slt")              \
+  X(Sle,    InstIcmp::ICond::Sge,    "sle")
+//#define X(tag, inverse, str)
 
 #endif // SUBZERO_SRC_ICEINST_DEF