[NFC] make TypeInfer::expandOverloads const

[craig.topper]

LGTM

[tmatheson]

Rebase

llvm/utils/TableGen/CodeGenDAGPatterns.h

struct TypeInfer {
   /// 1. Ensure that for each type T in \p A, there exists a type U in \p B,
   ///    such that T and U have equal size in bits.
   /// 2. Ensure that for each type U in \p B, there exists a type T in \p A
   ///    such that T and U have equal size in bits (reverse of 1).
   bool EnforceSameSize(TypeSetByHwMode &A, TypeSetByHwMode &B);
 
   /// For each overloaded type (i.e. of form *Any), replace it with the
   /// corresponding subset of legal, specific types.
-  void expandOverloads(TypeSetByHwMode &VTS);
+  void expandOverloads(TypeSetByHwMode &VTS) const;
   void expandOverloads(TypeSetByHwMode::SetType &Out,
-                       const TypeSetByHwMode::SetType &Legal);
+                       const TypeSetByHwMode::SetType &Legal) const;
 
   struct ValidateOnExit {
     ValidateOnExit(const TypeSetByHwMode &T, const TypeInfer &TI)
         : Infer(TI), VTS(T) {}
     ~ValidateOnExit();
     const TypeInfer &Infer;
     const TypeSetByHwMode &VTS;
   };
 
   struct SuppressValidation {
     SuppressValidation(TypeInfer &TI) : Infer(TI), SavedValidate(TI.Validate) {
       Infer.Validate = false;
     }
     ~SuppressValidation() {
       Infer.Validate = SavedValidate;
     }
     TypeInfer &Infer;
     bool SavedValidate;
   };
 
   TreePattern &TP;
   bool Validate = true;   // Indicate whether to validate types.
 
 private:
-  const TypeSetByHwMode &getLegalTypes();
+  const TypeSetByHwMode &getLegalTypes() const;
 
   /// Cached legal types (in default mode).
-  bool LegalTypesCached = false;
-  TypeSetByHwMode LegalCache;
+  mutable bool LegalTypesCached = false;
+  mutable TypeSetByHwMode LegalCache;
 };
 
 /// Set type used to track multiply used variables in patterns
 typedef StringSet<> MultipleUseVarSet;
 
 /// SDTypeConstraint - This is a discriminated union of constraints,
 /// corresponding to the SDTypeConstraint tablegen class in Target.td.
 struct SDTypeConstraint {

llvm/utils/TableGen/CodeGenDAGPatterns.cpp

for (unsigned M : Modes) {
 
     Changed |= berase_if(AS, std::bind(NoSize, BN, std::placeholders::_1));
     Changed |= berase_if(BS, std::bind(NoSize, AN, std::placeholders::_1));
   }
 
   return Changed;
 }
 
-void TypeInfer::expandOverloads(TypeSetByHwMode &VTS) {
+void TypeInfer::expandOverloads(TypeSetByHwMode &VTS) const {
   ValidateOnExit _1(VTS, *this);
   const TypeSetByHwMode &Legal = getLegalTypes();
   assert(Legal.isSimple() && "Default-mode only expected");
   const TypeSetByHwMode::SetType &LegalTypes = Legal.getSimple();
 
   for (auto &I : VTS)
     expandOverloads(I.second, LegalTypes);
 }
 
 void TypeInfer::expandOverloads(TypeSetByHwMode::SetType &Out,
-                                const TypeSetByHwMode::SetType &Legal) {
+                                const TypeSetByHwMode::SetType &Legal) const {
   if (Out.count(MVT::iPTRAny)) {
     Out.erase(MVT::iPTRAny);
     Out.insert(MVT::iPTR);
   } else if (Out.count(MVT::iAny)) {
     Out.erase(MVT::iAny);
     for (MVT T : MVT::integer_valuetypes())
       if (Legal.count(T))
         Out.insert(T);
void TypeInfer::expandOverloads(TypeSetByHwMode::SetType &Out,
   } else if (Out.count(MVT::Any)) {
     Out.erase(MVT::Any);
     for (MVT T : MVT::all_valuetypes())
       if (Legal.count(T))
         Out.insert(T);
   }
 }
 
-const TypeSetByHwMode &TypeInfer::getLegalTypes() {
+const TypeSetByHwMode &TypeInfer::getLegalTypes() const {
   if (!LegalTypesCached) {
     TypeSetByHwMode::SetType &LegalTypes = LegalCache.getOrCreate(DefaultMode);
     // Stuff all types from all modes into the default mode.
     const TypeSetByHwMode &LTS = TP.getDAGPatterns().getLegalTypes();
     for (const auto &I : LTS)
       LegalTypes.insert(I.second);
     LegalTypesCached = true;
   }