Better fix for incomplete DefaultPred

llvm/utils/TableGen/CodeGenDAGPatterns.cpp

 }
 
 void CodeGenDAGPatterns::ExpandHwModeBasedTypes() {
   const CodeGenHwModes &CGH = getTargetInfo().getHwModes();
   std::map<unsigned,std::vector<Predicate>> ModeChecks;
   std::vector<PatternToMatch> Copy;
   PatternsToMatch.swap(Copy);
 
-  auto AppendPattern = [this, &ModeChecks](PatternToMatch &P, unsigned Mode) {
+  auto AppendPattern = [this](PatternToMatch &P, unsigned Mode,
+                              const std::vector<Predicate> &Check) {
     TreePatternNodePtr NewSrc = P.getSrcPattern()->clone();
     TreePatternNodePtr NewDst = P.getDstPattern()->clone();
     if (!NewSrc->setDefaultMode(Mode) || !NewDst->setDefaultMode(Mode)) {
       return;
     }
 
     std::vector<Predicate> Preds = P.getPredicates();
-    const std::vector<Predicate> &MC = ModeChecks[Mode];
-    llvm::append_range(Preds, MC);
+    llvm::append_range(Preds, Check);
     PatternsToMatch.emplace_back(P.getSrcRecord(), std::move(Preds),
                                  std::move(NewSrc), std::move(NewDst),
                                  P.getDstRegs(),
                                  P.getAddedComplexity(), Record::getNewUID(),
                                  Mode);
   };
 
   for (PatternToMatch &P : Copy) {
for (PatternToMatch &P : Copy) {
     // absent, then there is no point in constructing a check for m. If such
     // a check was created, it would be equivalent to checking the default
     // mode, except not all modes' predicates would be a part of the checking
     // code. The subsequently generated check for the default mode would then
     // have the exact same patterns, but a different predicate code. To avoid
     // duplicated patterns with different predicate checks, construct the
     // default check as a negation of all predicates that are actually present
     // in the source/destination patterns.
-    std::vector<Predicate> DefaultPred;
+    std::vector<Predicate> DefaultCheck;
 
     for (unsigned M : Modes) {
       if (M == DefaultMode)
         continue;
-      if (ModeChecks.find(M) != ModeChecks.end())
-        continue;
 
-      // Fill the map entry for this mode.
       const HwMode &HM = CGH.getMode(M);
+      if (ModeChecks.find(M) == ModeChecks.end()) {
+        // Fill the map entry for this mode.
         ModeChecks[M].emplace_back(Predicate(HM.Features, true));
+      }
 
       // Add negations of the HM's predicates to the default predicate.
-      DefaultPred.emplace_back(Predicate(HM.Features, false));
+      DefaultCheck.emplace_back(Predicate(HM.Features, false));
     }
 
     for (unsigned M : Modes) {
       if (M == DefaultMode)
         continue;
-      AppendPattern(P, M);
+      AppendPattern(P, M, ModeChecks[M]);
     }
 
     bool HasDefault = Modes.count(DefaultMode);
     if (HasDefault)
-      AppendPattern(P, DefaultMode);
+      AppendPattern(P, DefaultMode, DefaultCheck);
   }
 }
 
 /// Dependent variable map for CodeGenDAGPattern variant generation
 typedef StringMap<int> DepVarMap;
 
 static void FindDepVarsOf(TreePatternNode *N, DepVarMap &DepMap) {
   if (N->isLeaf()) {