[RISCV] Use const reference when looping over Exts in RISCVISAInfo.

[craig.topper]

Summary

Exts is a map of keyed by std::string with a extension info as
a value. Making copies of this wouldn't be cheap.

We had a mix of references and copies. This makes everything
consistently use a const reference to make it clear we aren't
modifying it.

[kito-cheng]

LGTM, thanks :)

[asb]

LGTM.

llvm/lib/Support/RISCVISAInfo.cpp

bool RISCVISAInfo::compareExtension(const std::string &LHS,
 
   // If the rank is same, it must be sorted by lexicographic order.
   return LHS < RHS;
 }
 
 void RISCVISAInfo::toFeatures(
     std::vector<StringRef> &Features,
     std::function<StringRef(const Twine &)> StrAlloc) const {
-  for (auto &Ext : Exts) {
+  for (auto const &Ext : Exts) {
     StringRef ExtName = Ext.first;
 
     if (ExtName == "i")
       continue;
 
     if (isExperimentalExtension(ExtName)) {
       Features.push_back(StrAlloc("+experimental-" + ExtName));
     } else {
if (!HasE && !HasI) {
     addExtension("i", Version->Major, Version->Minor);
   }
 
   assert(llvm::is_sorted(ImpliedExts) && "Table not sorted by Name");
 
   // This loop may execute over 1 iteration since implication can be layered
   // Exits loop if no more implication is applied
   SmallSetVector<StringRef, 16> WorkList;
-  for (auto &Ext : Exts)
+  for (auto const &Ext : Exts)
     WorkList.insert(Ext.first);
 
   while (!WorkList.empty()) {
     StringRef ExtName = WorkList.pop_back_val();
     auto I = llvm::lower_bound(ImpliedExts, ExtName);
     if (I != std::end(ImpliedExts) && I->Name == ExtName) {
       for (const char *ImpliedExt : I->Exts) {
         if (WorkList.count(ImpliedExt))
void RISCVISAInfo::updateFLen() {
   // TODO: Handle q extension.
   if (Exts.count("d"))
     FLen = 64;
   else if (Exts.count("f"))
     FLen = 32;
 }
 
 void RISCVISAInfo::updateMinVLen() {
-  for (auto Ext : Exts) {
+  for (auto const &Ext : Exts) {
     StringRef ExtName = Ext.first;
     bool IsZvlExt = ExtName.consume_front("zvl") && ExtName.consume_back("b");
     if (IsZvlExt) {
       unsigned ZvlLen;
       if (!ExtName.getAsInteger(10, ZvlLen))
         MinVLen = std::max(MinVLen, ZvlLen);
     }
   }
 }
 
 void RISCVISAInfo::updateMaxELen() {
   // handles EEW restriction by sub-extension zve
-  for (auto Ext : Exts) {
+  for (auto const &Ext : Exts) {
     StringRef ExtName = Ext.first;
     bool IsZveExt = ExtName.consume_front("zve");
     if (IsZveExt) {
       if (ExtName.back() == 'f')
         MaxELenFp = std::max(MaxELenFp, 32u);
       if (ExtName.back() == 'd')
         MaxELenFp = std::max(MaxELenFp, 64u);
       ExtName = ExtName.drop_back();

 
 std::string RISCVISAInfo::toString() const {
   std::string Buffer;
   raw_string_ostream Arch(Buffer);
 
   Arch << "rv" << XLen;
 
   ListSeparator LS("_");
-  for (auto &Ext : Exts) {
+  for (auto const &Ext : Exts) {
     StringRef ExtName = Ext.first;
     auto ExtInfo = Ext.second;
     Arch << LS << ExtName;
     Arch << ExtInfo.MajorVersion << "p" << ExtInfo.MinorVersion;
   }
 
   return Arch.str();
 }
 
 std::vector<std::string> RISCVISAInfo::toFeatureVector() const {
   std::vector<std::string> FeatureVector;
-  for (auto Ext : Exts) {
+  for (auto const &Ext : Exts) {
     std::string ExtName = Ext.first;
     if (ExtName == "i") // i is not recognized in clang -cc1
       continue;
     std::string Feature = isExperimentalExtension(ExtName)
                               ? "+experimental-" + ExtName
                               : "+" + ExtName;
     FeatureVector.push_back(Feature);
   }
   return FeatureVector;
 }