[Tools] Fixes -Wrange-loop-analysis warnings

[Mordante]

Summary

This avoids new warnings due to D68912 adds -Wrange-loop-analysis to -Wall.

[aaron.ballman]

LGTM with a request to drop top-level consts.

llvm/tools/llvm-exegesis/lib/Clustering.cpp

255

Drop top-level const here and elsewhere?

llvm/tools/llvm-exegesis/lib/Clustering.cpp

struct OpcodeAndConfig {
     auto Tie() const -> auto { return std::tie(Opcode, *Config); }
 
     bool operator<(const OpcodeAndConfig &O) const { return Tie() < O.Tie(); }
     bool operator!=(const OpcodeAndConfig &O) const { return Tie() != O.Tie(); }
   };
   std::map<OpcodeAndConfig, SmallSet<ClusterId, 1>> OpcodeConfigToClusterIDs;
   // Populate OpcodeConfigToClusterIDs and UnstableOpcodes data structures.
   assert(ClusterIdForPoint_.size() == Points_.size() && "size mismatch");
-  for (const auto &Point : zip(Points_, ClusterIdForPoint_)) {
+  for (auto Point : zip(Points_, ClusterIdForPoint_)) {
     const ClusterId &ClusterIdOfPoint = std::get<1>(Point);
     if (!ClusterIdOfPoint.isValid())
       continue; // Only process fully valid clusters.
     const OpcodeAndConfig Key(std::get<0>(Point));
     SmallSet<ClusterId, 1> &ClusterIDsOfOpcode = OpcodeConfigToClusterIDs[Key];
     ClusterIDsOfOpcode.insert(ClusterIdOfPoint);
   }
 

 }
 
 void SchedClassClusterCentroid::addPoint(ArrayRef<BenchmarkMeasure> Point) {
   if (Representative.empty())
     Representative.resize(Point.size());
   assert(Representative.size() == Point.size() &&
          "All points should have identical dimensions.");
 
-  for (const auto &I : zip(Representative, Point))
+  for (auto I : zip(Representative, Point))
     std::get<0>(I).push(std::get<1>(I));
 }
 
 std::vector<BenchmarkMeasure> SchedClassClusterCentroid::getAsPoint() const {
   std::vector<BenchmarkMeasure> ClusterCenterPoint(Representative.size());
-  for (const auto &I : zip(ClusterCenterPoint, Representative))
+  for (auto I : zip(ClusterCenterPoint, Representative))
     std::get<0>(I).PerInstructionValue = std::get<1>(I).avg();
   return ClusterCenterPoint;
 }
 
 bool SchedClassClusterCentroid::validate(
     InstructionBenchmark::ModeE Mode) const {
   size_t NumMeasurements = Representative.size();
   switch (Mode) {

llvm/tools/llvm-exegesis/lib/SchedClassResolution.cpp

if (Mode == InstructionBenchmark::Latency) {
 
     for (unsigned I = 0; I < SCDesc->NumWriteLatencyEntries; ++I) {
       const MCWriteLatencyEntry *const WLE =
           STI.getWriteLatencyEntry(SCDesc, I);
       LatencyMeasure.PerInstructionValue =
           std::max<double>(LatencyMeasure.PerInstructionValue, WLE->Cycles);
     }
   } else if (Mode == InstructionBenchmark::Uops) {
-    for (const auto &I : zip(SchedClassPoint, Representative)) {
+    for (auto I : zip(SchedClassPoint, Representative)) {
       BenchmarkMeasure &Measure = std::get<0>(I);
       const PerInstructionStats &Stats = std::get<1>(I);
 
       StringRef Key = Stats.key();
       uint16_t ProcResIdx = findProcResIdx(STI, Key);
       if (ProcResIdx > 0) {
         // Find the pressure on ProcResIdx `Key`.
         const auto ProcResPressureIt = std::find_if(

llvm/tools/llvm-exegesis/llvm-exegesis.cpp

for (unsigned I = 1, E = MCInstrInfo.getNumOpcodes(); I < E; ++I)
       if (MCInstrInfo.getName(I) == OpcodeName)
         return I;
     return 0u;
   };
   SmallVector<StringRef, 2> Pieces;
   StringRef(OpcodeNames.getValue())
       .split(Pieces, ",", /* MaxSplit */ -1, /* KeepEmpty */ false);
   std::vector<unsigned> Result;
-  for (const StringRef OpcodeName : Pieces) {
+  for (const StringRef &OpcodeName : Pieces) {
     if (unsigned Opcode = ResolveName(OpcodeName))
       Result.push_back(Opcode);
     else
       report_fatal_error(Twine("unknown opcode ").concat(OpcodeName));
   }
   return Result;
 }
 

llvm/tools/llvm-mca/Views/DispatchStatistics.cpp

 }
 
 void DispatchStatistics::printDispatchHistogram(raw_ostream &OS) const {
   std::string Buffer;
   raw_string_ostream TempStream(Buffer);
   TempStream << "\n\nDispatch Logic - "
              << "number of cycles where we saw N micro opcodes dispatched:\n";
   TempStream << "[# dispatched], [# cycles]\n";
-  for (const std::pair<unsigned, unsigned> &Entry : DispatchGroupSizePerCycle) {
+  for (const std::pair<const unsigned, unsigned> &Entry :
+       DispatchGroupSizePerCycle) {
     double Percentage = ((double)Entry.second / NumCycles) * 100.0;
     TempStream << " " << Entry.first << ",              " << Entry.second
                << "  (" << format("%.1f", floor((Percentage * 10) + 0.5) / 10)
                << "%)\n";
   }
 
   TempStream.flush();
   OS << Buffer;

llvm/tools/llvm-mca/Views/RetireControlUnitStatistics.cpp

 
 void RetireControlUnitStatistics::printView(raw_ostream &OS) const {
   std::string Buffer;
   raw_string_ostream TempStream(Buffer);
   TempStream << "\n\nRetire Control Unit - "
              << "number of cycles where we saw N instructions retired:\n";
   TempStream << "[# retired], [# cycles]\n";
 
-  for (const std::pair<unsigned, unsigned> &Entry : RetiredPerCycle) {
+  for (const std::pair<const unsigned, unsigned> &Entry : RetiredPerCycle) {
     TempStream << " " << Entry.first;
     if (Entry.first < 10)
       TempStream << ",           ";
     else
       TempStream << ",          ";
     TempStream << Entry.second << "  ("
                << format("%.1f", ((double)Entry.second / NumCycles) * 100.0)
                << "%)\n";

llvm/tools/llvm-mca/Views/SchedulerStatistics.cpp

 void SchedulerStatistics::printSchedulerStats(raw_ostream &OS) const {
   OS << "\n\nSchedulers - "
      << "number of cycles where we saw N micro opcodes issued:\n";
   OS << "[# issued], [# cycles]\n";
 
   bool HasColors = OS.has_colors();
   const auto It =
       std::max_element(IssueWidthPerCycle.begin(), IssueWidthPerCycle.end());
-  for (const std::pair<unsigned, unsigned> &Entry : IssueWidthPerCycle) {
+  for (const std::pair<const unsigned, unsigned> &Entry : IssueWidthPerCycle) {
     unsigned NumIssued = Entry.first;
     if (NumIssued == It->first && HasColors)
       OS.changeColor(raw_ostream::SAVEDCOLOR, true, false);
 
     unsigned IPC = Entry.second;
     OS << " " << NumIssued << ",          " << IPC << "  ("
        << format("%.1f", ((double)IPC / NumCycles) * 100) << "%)\n";
     if (HasColors)

llvm/tools/llvm-mca/Views/SummaryView.cpp

void SummaryView::onEvent(const HWInstructionEvent &Event) {
 
   // Update the cumulative number of resource cycles based on the processor
   // resource usage information available from the instruction descriptor. We
   // need to compute the cumulative number of resource cycles for every
   // processor resource which is consumed by an instruction of the block.
   const Instruction &Inst = *Event.IR.getInstruction();
   const InstrDesc &Desc = Inst.getDesc();
   NumMicroOps += Desc.NumMicroOps;
-  for (const std::pair<uint64_t, const ResourceUsage> &RU : Desc.Resources) {
+  for (const std::pair<uint64_t, ResourceUsage> &RU : Desc.Resources) {
     if (RU.second.size()) {
       unsigned ProcResID = ResIdx2ProcResID[getResourceStateIndex(RU.first)];
       ProcResourceUsage[ProcResID] += RU.second.size();
     }
   }
 }
 
 void SummaryView::printView(raw_ostream &OS) const {

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

findBuildID(const CopyConfig &Config, const object::ELFFile<ELFT> &In) {
   auto PhdrsOrErr = In.program_headers();
   if (auto Err = PhdrsOrErr.takeError())
     return createFileError(Config.InputFilename, std::move(Err));
 
   for (const auto &Phdr : *PhdrsOrErr) {
     if (Phdr.p_type != PT_NOTE)
       continue;
     Error Err = Error::success();
-    for (const auto &Note : In.notes(Phdr, Err))
+    for (auto Note : In.notes(Phdr, Err))
       if (Note.getType() == NT_GNU_BUILD_ID && Note.getName() == ELF_NOTE_GNU)
         return Note.getDesc();
     if (Err)
       return createFileError(Config.InputFilename, std::move(Err));
   }
 
   return createFileError(
       Config.InputFilename,

llvm/tools/llvm-pdbutil/DumpOutputStyle.cpp

if (opts::dump::DumpTypes) {
                          opts::dump::DumpTypeData, false);
     } else if (opts::dump::DumpTypeExtras) {
       auto LocalHashes = LocallyHashedType::hashTypeCollection(Types);
       auto GlobalHashes = GloballyHashedType::hashTypeCollection(Types);
       assert(LocalHashes.size() == GlobalHashes.size());
 
       P.formatLine("Local / Global hashes:");
       TypeIndex TI(TypeIndex::FirstNonSimpleIndex);
-      for (const auto &H : zip(LocalHashes, GlobalHashes)) {
+      for (auto H : zip(LocalHashes, GlobalHashes)) {
         AutoIndent Indent2(P);
         LocallyHashedType &L = std::get<0>(H);
         GloballyHashedType &G = std::get<1>(H);
 
         P.formatLine("TI: {0}, LocalHash: {1:X}, GlobalHash: {2}", TI, L, G);
 
         ++TI;
       }

llvm/tools/llvm-readobj/ELFDumper.cpp

void GNUStyle<ELFT>::printNotes(const ELFFile<ELFT> *Obj) {
 
   ArrayRef<Elf_Shdr> Sections = unwrapOrError(this->FileName, Obj->sections());
   if (Obj->getHeader()->e_type != ELF::ET_CORE && !Sections.empty()) {
     for (const auto &S : Sections) {
       if (S.sh_type != SHT_NOTE)
         continue;
       PrintHeader(S.sh_offset, S.sh_size);
       Error Err = Error::success();
-      for (const auto &Note : Obj->notes(S, Err))
+      for (auto Note : Obj->notes(S, Err))
         ProcessNote(Note);
       if (Err)
         reportError(std::move(Err), this->FileName);
     }
   } else {
     for (const auto &P :
          unwrapOrError(this->FileName, Obj->program_headers())) {
       if (P.p_type != PT_NOTE)
         continue;
       PrintHeader(P.p_offset, P.p_filesz);
       Error Err = Error::success();
-      for (const auto &Note : Obj->notes(P, Err))
+      for (auto Note : Obj->notes(P, Err))
         ProcessNote(Note);
       if (Err)
         reportError(std::move(Err), this->FileName);
     }
   }
 }
 
 template <class ELFT>
void LLVMStyle<ELFT>::printNotes(const ELFFile<ELFT> *Obj) {
   ArrayRef<Elf_Shdr> Sections = unwrapOrError(this->FileName, Obj->sections());
   if (Obj->getHeader()->e_type != ELF::ET_CORE && !Sections.empty()) {
     for (const auto &S : Sections) {
       if (S.sh_type != SHT_NOTE)
         continue;
       DictScope D(W, "NoteSection");
       PrintHeader(S.sh_offset, S.sh_size);
       Error Err = Error::success();
-      for (const auto &Note : Obj->notes(S, Err))
+      for (auto Note : Obj->notes(S, Err))
         ProcessNote(Note);
       if (Err)
         reportError(std::move(Err), this->FileName);
     }
   } else {
     for (const auto &P :
          unwrapOrError(this->FileName, Obj->program_headers())) {
       if (P.p_type != PT_NOTE)
         continue;
       DictScope D(W, "NoteSection");
       PrintHeader(P.p_offset, P.p_filesz);
       Error Err = Error::success();
-      for (const auto &Note : Obj->notes(P, Err))
+      for (auto Note : Obj->notes(P, Err))
         ProcessNote(Note);
       if (Err)
         reportError(std::move(Err), this->FileName);
     }
   }
 }
 
 template <class ELFT>

llvm/tools/llvm-readobj/ObjDumper.cpp

for (object::SectionRef SecRef : Obj->sections()) {
     auto IndexIt = SecIndices.find(SecIndex);
     if (IndexIt != SecIndices.end())
       IndexIt->second = true;
     if (NameIt != SecNames.end() || IndexIt != SecIndices.end())
       Ret.push_back(SecRef);
     SecIndex++;
   }
 
-  for (const std::pair<std::string, bool> &S : SecNames)
+  for (const std::pair<const std::string, bool> &S : SecNames)
     if (!S.second)
       reportWarning(
           createError(formatv("could not find section '{0}'", S.first).str()),
           Obj->getFileName());
 
   for (std::pair<unsigned, bool> S : SecIndices)
     if (!S.second)
       reportWarning(