[NFC] Elminate some needless nested-map complexity.

[nikic]

LG

[resistor]

Rebase

llvm/utils/TableGen/FastISelEmitter.cpp

class FastISelMap {
   typedef std::map<MVT::SimpleValueType, RetPredMap> TypeRetPredMap;
   typedef std::map<std::string, TypeRetPredMap> OpcodeTypeRetPredMap;
   typedef std::map<OperandsSignature, OpcodeTypeRetPredMap>
             OperandsOpcodeTypeRetPredMap;
 
   OperandsOpcodeTypeRetPredMap SimplePatterns;
 
   // This is used to check that there are no duplicate predicates
-  typedef std::multimap<std::string, bool> PredCheckMap;
-  typedef std::map<MVT::SimpleValueType, PredCheckMap> RetPredCheckMap;
-  typedef std::map<MVT::SimpleValueType, RetPredCheckMap> TypeRetPredCheckMap;
-  typedef std::map<std::string, TypeRetPredCheckMap> OpcodeTypeRetPredCheckMap;
-  typedef std::map<OperandsSignature, OpcodeTypeRetPredCheckMap>
-            OperandsOpcodeTypeRetPredCheckMap;
-
-  OperandsOpcodeTypeRetPredCheckMap SimplePatternsCheck;
+  std::set<std::tuple<OperandsSignature, std::string, MVT::SimpleValueType,
+                      MVT::SimpleValueType, std::string>>
+      SimplePatternsCheck;
 
   std::map<OperandsSignature, std::vector<OperandsSignature> >
     SignaturesWithConstantForms;
 
   StringRef InstNS;
   ImmPredicateSet ImmediatePredicates;
 public:
   explicit FastISelMap(StringRef InstNS);
InstructionMemo Memo(
       DstRC,
       SubRegNo,
       PhysRegInputs,
       PredicateCheck
     );
 
     int complexity = Pattern.getPatternComplexity(CGP);
 
-    if (SimplePatternsCheck[Operands][OpcodeName][VT]
-         [RetVT].count(PredicateCheck)) {
+    auto inserted_simple_pattern = SimplePatternsCheck.insert(
+        std::make_tuple(Operands, OpcodeName, VT, RetVT, PredicateCheck));
+    if (!inserted_simple_pattern.second) {
       PrintFatalError(Pattern.getSrcRecord()->getLoc(),
                     "Duplicate predicate in FastISel table!");
     }
-    SimplePatternsCheck[Operands][OpcodeName][VT][RetVT].insert(
-            std::make_pair(PredicateCheck, true));
 
-       // Note: Instructions with the same complexity will appear in the order
-          // that they are encountered.
     SimplePatterns[Operands][OpcodeName][VT][RetVT].emplace(complexity,
                                                             std::move(Memo));
 
     // If any of the operands were immediates with predicates on them, strip
     // them down to a signature that doesn't have predicates so that we can
     // associate them with the stripped predicate version.
     if (Operands.hasAnyImmediateCodes()) {
       SignaturesWithConstantForms[Operands.getWithoutImmCodes()]