[TableGen][GlobalISel] Fix unused variable warnings

llvm/utils/TableGen/GlobalISelCombinerMatchTableEmitter.cpp

 }
 
 void declareOperandExpansion(CodeExpansions &CE, const OperandMatcher &OM,
                              StringRef Name) {
   CE.declare(Name, "State.MIs[" + to_string(OM.getInsnVarID()) +
                        "]->getOperand(" + to_string(OM.getOpIdx()) + ")");
 }
 
+template <typename Container> auto keys(Container &&C) {
+  return map_range(C, [](auto &Entry) -> auto & { return Entry.first; });
+}
+
+template <typename Container> auto values(Container &&C) {
+  return map_range(C, [](auto &Entry) -> auto & { return Entry.second; });
+}
+
 //===- MatchData Handling -------------------------------------------------===//
 
 /// Represents MatchData defined by the match stage and required by the apply
 /// stage.
 ///
 /// This allows the plumbing of arbitrary data from C++ predicates between the
 /// stages.
 ///
bool CombineRuleBuilder::findRoots() {
   }
 
   MatchRoot = It->second.MatchPat;
   return true;
 }
 
 bool CombineRuleBuilder::buildOperandsTable() {
   // Walk each instruction pattern
-  for (auto &[_, P] : MatchPats) {
+  for (auto &P : values(MatchPats)) {
     auto *IP = dyn_cast<InstructionPattern>(P.get());
     if (!IP)
       continue;
     for (const auto &Operand : IP->operands()) {
       // Create an entry, no matter if it's a use or a def.
       auto &Entry = OperandTable[Operand.Name];
 
       // We only need to do additional checking on defs, though.
       if (!Operand.IsDef)
         continue;
 
       if (Entry.MatchPat) {
         PrintError("Operand '" + Operand.Name +
                    "' is defined multiple times in the 'match' patterns");
         return false;
       }
       Entry.MatchPat = IP;
     }
   }
 
-  for (auto &[_, P] : ApplyPats) {
+  for (auto &P : values(ApplyPats)) {
     auto *IP = dyn_cast<InstructionPattern>(P.get());
     if (!IP)
       continue;
     for (const auto &Operand : IP->operands()) {
       // Create an entry, no matter if it's a use or a def.
       auto &Entry = OperandTable[Operand.Name];
 
       // We only need to do additional checking on defs, though.
bool CombineRuleBuilder::emitMatchPattern(CodeExpansions &CE,
   InstructionMatcher &IM = M.addInstructionMatcher("root");
   declareInstExpansion(CE, IM, IP.getName());
 
   DenseSet<const Pattern *> SeenPats;
   if (!emitInstructionMatchPattern(CE, M, IM, IP, SeenPats))
     return false;
 
   // Emit remaining patterns
-  for (auto &[_, Pat] : MatchPats) {
+  for (auto &Pat : values(MatchPats)) {
     if (SeenPats.contains(Pat.get()))
       continue;
 
     switch (Pat->getKind()) {
     case Pattern::K_AnyOpcode:
       PrintError("wip_match_opcode can not be used with instruction patterns!");
       return false;
     case Pattern::K_Inst:
for (const CodeGenInstruction *CGI : AOP.insts()) {
     declareInstExpansion(CE, IM, AOP.getName());
     // declareInstExpansion needs to be identical, otherwise we need to create a
     // CodeExpansions object here instead.
     assert(IM.getInsnVarID() == 0);
 
     IM.addPredicate<InstructionOpcodeMatcher>(CGI);
 
     // Emit remaining patterns.
-    for (auto &[_, Pat] : MatchPats) {
+    for (auto &Pat : values(MatchPats)) {
       if (Pat.get() == &AOP)
         continue;
 
       switch (Pat->getKind()) {
       case Pattern::K_AnyOpcode:
         PrintError("wip_match_opcode can only be present once!");
         return false;
       case Pattern::K_Inst:
for (const CodeGenInstruction *CGI : AOP.insts()) {
     if (!emitApplyPatterns(CE, M))
       return false;
   }
 
   return true;
 }
 
 bool CombineRuleBuilder::emitApplyPatterns(CodeExpansions &CE, RuleMatcher &M) {
-  for (auto &[_, Pat] : ApplyPats) {
+  for (auto &Pat : values(ApplyPats)) {
     switch (Pat->getKind()) {
     case Pattern::K_AnyOpcode:
     case Pattern::K_Inst:
       llvm_unreachable("Unsupported pattern kind in output pattern!");
     case Pattern::K_CXX: {
       CXXPattern *CXXPat = cast<CXXPattern>(Pat.get());
       const auto &ExpandedCode = CXXPat->expandCode(CE, RuleDef.getLoc());
       M.addAction<CustomCXXAction>(
void GICombinerEmitter::emitTestSimplePredicate(raw_ostream &OS) {
   if (!AllCombineRules.empty()) {
     OS << "enum {\n";
     std::string EnumeratorSeparator = " = GICXXPred_Invalid + 1,\n";
     // To avoid emitting a switch, we expect that all those rules are in order.
     // That way we can just get the RuleID from the enum by subtracting
     // (GICXXPred_Invalid + 1).
     unsigned ExpectedID = 0;
     (void)ExpectedID;
-    for (const auto &[ID, _] : AllCombineRules) {
+    for (const auto &ID : keys(AllCombineRules)) {
       assert(ExpectedID++ == ID && "combine rules are not ordered!");
       OS << "  " << getIsEnabledPredicateEnumName(ID) << EnumeratorSeparator;
       EnumeratorSeparator = ",\n";
     }
     OS << "};\n\n";
   }
 
   OS << "bool " << getClassName()