[TableGen] TypeSetByHwMode::operator== optimization

[RKSimon]

Summary

This operator is called a great deal, by checking for the cheap isSimple equality cases first (a common occurrence) we can improve performance as we avoid a lot of std::map find/iteration in hasDefault.

isSimple also means that a default value is present, so we can avoid some hasDefault calls.

This also avoids a rather dodgy piece of logic that was checking for isSimple() && !VTS.isSimple() but not the inverse - it now uses the general hasDefault mode comparison test instead.

Saves around 15secs in debug builds of x86 -gen-dag-isel.

[kparzysz]

A bit of a background for clarity: <Something>ByHwMode represents <Something> parameterized by hardware mode. It's a map that to each hw mode assigns the corresponding value of <Something>. If a value for mode m is missing from the map, the default is used (this is a form of compression).

TypeSetByHwMode are sets of MVTs corresponding to hw modes. They are used in definitions of RegisterClasses, so that a given class can have value types i32 and v2i16 in 32-bit mode, and i64, v2i32, and v4i16 in 64-bit mode.

Here, the attempt here was to compare the two parameterized type sets taking into account that if the set for a particular mode is missing, the default will be assumed. Specifically,

default -> { i32 }

should compare identical to

default -> { i32 }
mode0 -> { i32 }

and similarly

default -> { i32 }
mode0 -> { i32 }

should compare identical to

default -> { i32 }
mode0 -> { i32 }
mode1 -> { i32 }

On targets that don't use this feature, all TypeSetByHwModes are in the form of a map with a single entry: default -> { ... }, which is what isSimple checks for. The case where both parameterized sets are simple is the case for X86 and most other targets, so I agree that it should be made fast. If any of them isn't simple, it means that we are dealing with parameterized sets and they should be handled more carefully. The return false at line 208 in the original code was erroneous, since it did not perform the expanded checks in that specific case.

[kparzysz]

Looks good to me.

llvm/trunk/utils/TableGen/CodeGenDAGPatterns.cpp

for (unsigned i = 0, e = Types.size(); i != e; ++i) {
     OS << ValueTypeByHwMode::getMVTName(Types[i]);
     if (i != e-1)
       OS << ' ';
   }
   OS << ']';
 }
 
 bool TypeSetByHwMode::operator==(const TypeSetByHwMode &VTS) const {
-  bool HaveDefault = hasDefault();
-  if (HaveDefault != VTS.hasDefault())
-    return false;
-
-  if (isSimple()) {
-    if (VTS.isSimple())
-      return *begin() == *VTS.begin();
+  // The isSimple call is much quicker than hasDefault - check this first.
+  bool IsSimple = isSimple();
+  bool VTSIsSimple = VTS.isSimple();
+  if (IsSimple && VTSIsSimple)
+
+  // Speedup: We have a default if the set is simple.
+  bool HaveDefault = IsSimple || hasDefault();
+  bool VTSHaveDefault = VTSIsSimple || VTS.hasDefault();
+  if (HaveDefault != VTSHaveDefault)
     return false;
-  }
 
   SmallDenseSet<unsigned, 4> Modes;
   for (auto &I : *this)
     Modes.insert(I.first);
   for (const auto &I : VTS)
     Modes.insert(I.first);
 
   if (HaveDefault) {