[NFC] Use `llvm::enumerate` in llvm/unittests/Object

[barannikov88]

Rebase onto main

[MaskRay]

non-reference auto shall work better in these cases.

[barannikov88]

In D141788#4055263, @MaskRay wrote:

non-reference auto shall work better in these cases.

Not sure why? Won't Data be copied every iteration?

[barannikov88]

Use auto instead of const auto &
Rebase

clang/docs/tools/clang-formatted-files.txt

 llvm/unittests/MC/Disassembler.cpp
 llvm/unittests/MC/DwarfLineTableHeaders.cpp
 llvm/unittests/MC/MCInstPrinter.cpp
 llvm/unittests/MC/TargetRegistry.cpp
 llvm/unittests/MC/AMDGPU/DwarfRegMappings.cpp
 llvm/unittests/MC/SystemZ/SystemZAsmLexerTest.cpp
 llvm/unittests/ObjCopy/ObjCopyTest.cpp
 llvm/unittests/Object/ArchiveTest.cpp
+llvm/unittests/Object/ELFObjectFileTest.cpp
 llvm/unittests/Object/ELFTest.cpp
 llvm/unittests/Object/ELFTypesTest.cpp
 llvm/unittests/Object/MinidumpTest.cpp
 llvm/unittests/Object/ObjectFileTest.cpp
 llvm/unittests/Object/SymbolSizeTest.cpp
 llvm/unittests/ObjectYAML/DWARFYAMLTest.cpp
 llvm/unittests/ObjectYAML/ELFYAMLTest.cpp
 llvm/unittests/ObjectYAML/MinidumpYAMLTest.cpp

llvm/unittests/Object/ELFObjectFileTest.cpp

 //===- ELFObjectFileTest.cpp - Tests for ELFObjectFile --------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Object/ELFObjectFile.h"
-#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ObjectYAML/yaml2obj.h"
+#include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/Testing/Support/Error.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace llvm::object;
 
 namespace {
return {DataForTest(ELF::ELFCLASS32, ELF::ELFDATA2LSB, Machine),
           DataForTest(ELF::ELFCLASS64, ELF::ELFDATA2MSB, Machine)};
 }
 
 } // namespace
 
 TEST(ELFObjectFileTest, MachineTestForNoneOrUnused) {
   std::array<StringRef, 4> Formats = {"elf32-unknown", "elf32-unknown",
                                       "elf64-unknown", "elf64-unknown"};
-  size_t I = 0;
-  for (const DataForTest &D : generateData(ELF::EM_NONE))
-    checkFormatAndArch(D, Formats[I++], Triple::UnknownArch);
+  for (auto [Idx, Data] : enumerate(generateData(ELF::EM_NONE)))
+    checkFormatAndArch(Data, Formats[Idx], Triple::UnknownArch);
 
   // Test an arbitrary unused EM_* value (255).
-  I = 0;
-  for (const DataForTest &D : generateData(255))
-    checkFormatAndArch(D, Formats[I++], Triple::UnknownArch);
+  for (auto [Idx, Data] : enumerate(generateData(255)))
+    checkFormatAndArch(Data, Formats[Idx], Triple::UnknownArch);
 }
 
 TEST(ELFObjectFileTest, MachineTestForVE) {
   std::array<StringRef, 4> Formats = {"elf32-unknown", "elf32-unknown",
                                       "elf64-ve", "elf64-ve"};
-  size_t I = 0;
-  for (const DataForTest &D : generateData(ELF::EM_VE))
-    checkFormatAndArch(D, Formats[I++], Triple::ve);
+  for (auto [Idx, Data] : enumerate(generateData(ELF::EM_VE)))
+    checkFormatAndArch(Data, Formats[Idx], Triple::ve);
 }
 
 TEST(ELFObjectFileTest, MachineTestForX86_64) {
   std::array<StringRef, 4> Formats = {"elf32-x86-64", "elf32-x86-64",
                                       "elf64-x86-64", "elf64-x86-64"};
-  size_t I = 0;
-  for (const DataForTest &D : generateData(ELF::EM_X86_64))
-    checkFormatAndArch(D, Formats[I++], Triple::x86_64);
+  for (auto [Idx, Data] : enumerate(generateData(ELF::EM_X86_64)))
+    checkFormatAndArch(Data, Formats[Idx], Triple::x86_64);
 }
 
 TEST(ELFObjectFileTest, MachineTestFor386) {
   std::array<StringRef, 4> Formats = {"elf32-i386", "elf32-i386", "elf64-i386",
                                       "elf64-i386"};
-  size_t I = 0;
-  for (const DataForTest &D : generateData(ELF::EM_386))
-    checkFormatAndArch(D, Formats[I++], Triple::x86);
+  for (auto [Idx, Data] : enumerate(generateData(ELF::EM_386)))
+    checkFormatAndArch(Data, Formats[Idx], Triple::x86);
 }
 
 TEST(ELFObjectFileTest, MachineTestForMIPS) {
   std::array<StringRef, 4> Formats = {"elf32-mips", "elf32-mips", "elf64-mips",
                                       "elf64-mips"};
   std::array<Triple::ArchType, 4> Archs = {Triple::mipsel, Triple::mips,
                                            Triple::mips64el, Triple::mips64};
-  size_t I = 0;
-  for (const DataForTest &D : generateData(ELF::EM_MIPS)) {
-    checkFormatAndArch(D, Formats[I], Archs[I]);
-    ++I;
-  }
+  for (auto [Idx, Data] : enumerate(generateData(ELF::EM_MIPS)))
+    checkFormatAndArch(Data, Formats[Idx], Archs[Idx]);
 }
 
 TEST(ELFObjectFileTest, MachineTestForAMDGPU) {
   std::array<StringRef, 4> Formats = {"elf32-amdgpu", "elf32-amdgpu",
                                       "elf64-amdgpu", "elf64-amdgpu"};
-  size_t I = 0;
-  for (const DataForTest &D : generateData(ELF::EM_AMDGPU))
-    checkFormatAndArch(D, Formats[I++], Triple::UnknownArch);
+  for (auto [Idx, Data] : enumerate(generateData(ELF::EM_AMDGPU)))
+    checkFormatAndArch(Data, Formats[Idx], Triple::UnknownArch);
 }
 
 TEST(ELFObjectFileTest, MachineTestForIAMCU) {
   std::array<StringRef, 4> Formats = {"elf32-iamcu", "elf32-iamcu",
                                       "elf64-unknown", "elf64-unknown"};
-  size_t I = 0;
-  for (const DataForTest &D : generateData(ELF::EM_IAMCU))
-    checkFormatAndArch(D, Formats[I++], Triple::x86);
+  for (auto [Idx, Data] : enumerate(generateData(ELF::EM_IAMCU)))
+    checkFormatAndArch(Data, Formats[Idx], Triple::x86);
 }
 
 TEST(ELFObjectFileTest, MachineTestForAARCH64) {
   std::array<StringRef, 4> Formats = {"elf32-unknown", "elf32-unknown",
                                       "elf64-littleaarch64",
                                       "elf64-bigaarch64"};
   std::array<Triple::ArchType, 4> Archs = {Triple::aarch64, Triple::aarch64_be,
                                            Triple::aarch64, Triple::aarch64_be};
-  size_t I = 0;
-  for (const DataForTest &D : generateData(ELF::EM_AARCH64)) {
-    checkFormatAndArch(D, Formats[I], Archs[I]);
-    ++I;
-  }
+  for (auto [Idx, Data] : enumerate(generateData(ELF::EM_AARCH64)))
+    checkFormatAndArch(Data, Formats[Idx], Archs[Idx]);
 }
 
 TEST(ELFObjectFileTest, MachineTestForPPC64) {
   std::array<StringRef, 4> Formats = {"elf32-unknown", "elf32-unknown",
                                       "elf64-powerpcle", "elf64-powerpc"};
   std::array<Triple::ArchType, 4> Archs = {Triple::ppc64le, Triple::ppc64,
                                            Triple::ppc64le, Triple::ppc64};
-  size_t I = 0;
-  for (const DataForTest &D : generateData(ELF::EM_PPC64)) {
-    checkFormatAndArch(D, Formats[I], Archs[I]);
-    ++I;
-  }
+  for (auto [Idx, Data] : enumerate(generateData(ELF::EM_PPC64)))
+    checkFormatAndArch(Data, Formats[Idx], Archs[Idx]);
 }
 
 TEST(ELFObjectFileTest, MachineTestForPPC) {
   std::array<StringRef, 4> Formats = {"elf32-powerpcle", "elf32-powerpc",
                                       "elf64-unknown", "elf64-unknown"};
   std::array<Triple::ArchType, 4> Archs = {Triple::ppcle, Triple::ppc,
                                            Triple::ppcle, Triple::ppc};
-  size_t I = 0;
-  for (const DataForTest &D : generateData(ELF::EM_PPC)) {
-    checkFormatAndArch(D, Formats[I], Archs[I]);
-    ++I;
-  }
+  for (auto [Idx, Data] : enumerate(generateData(ELF::EM_PPC)))
+    checkFormatAndArch(Data, Formats[Idx], Archs[Idx]);
 }
 
 TEST(ELFObjectFileTest, MachineTestForRISCV) {
   std::array<StringRef, 4> Formats = {"elf32-littleriscv", "elf32-littleriscv",
                                       "elf64-littleriscv", "elf64-littleriscv"};
   std::array<Triple::ArchType, 4> Archs = {Triple::riscv32, Triple::riscv32,
                                            Triple::riscv64, Triple::riscv64};
-  size_t I = 0;
-  for (const DataForTest &D : generateData(ELF::EM_RISCV)) {
-    checkFormatAndArch(D, Formats[I], Archs[I]);
-    ++I;
-  }
+  for (auto [Idx, Data] : enumerate(generateData(ELF::EM_RISCV)))
+    checkFormatAndArch(Data, Formats[Idx], Archs[Idx]);
 }
 
 TEST(ELFObjectFileTest, MachineTestForARM) {
   std::array<StringRef, 4> Formats = {"elf32-littlearm", "elf32-bigarm",
                                       "elf64-unknown", "elf64-unknown"};
-  size_t I = 0;
-  for (const DataForTest &D : generateData(ELF::EM_ARM))
-    checkFormatAndArch(D, Formats[I++], Triple::arm);
+  for (auto [Idx, Data] : enumerate(generateData(ELF::EM_ARM)))
+    checkFormatAndArch(Data, Formats[Idx], Triple::arm);
 }
 
 TEST(ELFObjectFileTest, MachineTestForS390) {
   std::array<StringRef, 4> Formats = {"elf32-unknown", "elf32-unknown",
                                       "elf64-s390", "elf64-s390"};
-  size_t I = 0;
-  for (const DataForTest &D : generateData(ELF::EM_S390))
-    checkFormatAndArch(D, Formats[I++], Triple::systemz);
+  for (auto [Idx, Data] : enumerate(generateData(ELF::EM_S390)))
+    checkFormatAndArch(Data, Formats[Idx], Triple::systemz);
 }
 
 TEST(ELFObjectFileTest, MachineTestForSPARCV9) {
   std::array<StringRef, 4> Formats = {"elf32-unknown", "elf32-unknown",
                                       "elf64-sparc", "elf64-sparc"};
-  size_t I = 0;
-  for (const DataForTest &D : generateData(ELF::EM_SPARCV9))
-    checkFormatAndArch(D, Formats[I++], Triple::sparcv9);
+  for (auto [Idx, Data] : enumerate(generateData(ELF::EM_SPARCV9)))
+    checkFormatAndArch(Data, Formats[Idx], Triple::sparcv9);
 }
 
 TEST(ELFObjectFileTest, MachineTestForSPARC) {
   std::array<StringRef, 4> Formats = {"elf32-sparc", "elf32-sparc",
                                       "elf64-unknown", "elf64-unknown"};
   std::array<Triple::ArchType, 4> Archs = {Triple::sparcel, Triple::sparc,
                                            Triple::sparcel, Triple::sparc};
-  size_t I = 0;
-  for (const DataForTest &D : generateData(ELF::EM_SPARC)) {
-    checkFormatAndArch(D, Formats[I], Archs[I]);
-    ++I;
-  }
+  for (auto [Idx, Data] : enumerate(generateData(ELF::EM_SPARC)))
+    checkFormatAndArch(Data, Formats[Idx], Archs[Idx]);
 }
 
 TEST(ELFObjectFileTest, MachineTestForSPARC32PLUS) {
   std::array<StringRef, 4> Formats = {"elf32-sparc", "elf32-sparc",
                                       "elf64-unknown", "elf64-unknown"};
   std::array<Triple::ArchType, 4> Archs = {Triple::sparcel, Triple::sparc,
                                            Triple::sparcel, Triple::sparc};
-  size_t I = 0;
-  for (const DataForTest &D : generateData(ELF::EM_SPARC32PLUS)) {
-    checkFormatAndArch(D, Formats[I], Archs[I]);
-    ++I;
-  }
+  for (auto [Idx, Data] : enumerate(generateData(ELF::EM_SPARC32PLUS)))
+    checkFormatAndArch(Data, Formats[Idx], Archs[Idx]);
 }
 
 TEST(ELFObjectFileTest, MachineTestForBPF) {
   std::array<StringRef, 4> Formats = {"elf32-unknown", "elf32-unknown",
                                       "elf64-bpf", "elf64-bpf"};
   std::array<Triple::ArchType, 4> Archs = {Triple::bpfel, Triple::bpfeb,
                                            Triple::bpfel, Triple::bpfeb};
-  size_t I = 0;
-  for (const DataForTest &D : generateData(ELF::EM_BPF)) {
-    checkFormatAndArch(D, Formats[I], Archs[I]);
-    ++I;
-  }
+  for (auto [Idx, Data] : enumerate(generateData(ELF::EM_BPF)))
+    checkFormatAndArch(Data, Formats[Idx], Archs[Idx]);
 }
 
 TEST(ELFObjectFileTest, MachineTestForAVR) {
   std::array<StringRef, 4> Formats = {"elf32-avr", "elf32-avr", "elf64-unknown",
                                       "elf64-unknown"};
-  size_t I = 0;
-  for (const DataForTest &D : generateData(ELF::EM_AVR))
-    checkFormatAndArch(D, Formats[I++], Triple::avr);
+  for (auto [Idx, Data] : enumerate(generateData(ELF::EM_AVR)))
+    checkFormatAndArch(Data, Formats[Idx], Triple::avr);
 }
 
 TEST(ELFObjectFileTest, MachineTestForHEXAGON) {
   std::array<StringRef, 4> Formats = {"elf32-hexagon", "elf32-hexagon",
                                       "elf64-unknown", "elf64-unknown"};
-  size_t I = 0;
-  for (const DataForTest &D : generateData(ELF::EM_HEXAGON))
-    checkFormatAndArch(D, Formats[I++], Triple::hexagon);
+  for (auto [Idx, Data] : enumerate(generateData(ELF::EM_HEXAGON)))
+    checkFormatAndArch(Data, Formats[Idx], Triple::hexagon);
 }
 
 TEST(ELFObjectFileTest, MachineTestForLANAI) {
   std::array<StringRef, 4> Formats = {"elf32-lanai", "elf32-lanai",
                                       "elf64-unknown", "elf64-unknown"};
-  size_t I = 0;
-  for (const DataForTest &D : generateData(ELF::EM_LANAI))
-    checkFormatAndArch(D, Formats[I++], Triple::lanai);
+  for (auto [Idx, Data] : enumerate(generateData(ELF::EM_LANAI)))
+    checkFormatAndArch(Data, Formats[Idx], Triple::lanai);
 }
 
 TEST(ELFObjectFileTest, MachineTestForMSP430) {
   std::array<StringRef, 4> Formats = {"elf32-msp430", "elf32-msp430",
                                       "elf64-unknown", "elf64-unknown"};
-  size_t I = 0;
-  for (const DataForTest &D : generateData(ELF::EM_MSP430))
-    checkFormatAndArch(D, Formats[I++], Triple::msp430);
+  for (auto [Idx, Data] : enumerate(generateData(ELF::EM_MSP430)))
+    checkFormatAndArch(Data, Formats[Idx], Triple::msp430);
 }
 
 TEST(ELFObjectFileTest, MachineTestForLoongArch) {
   std::array<StringRef, 4> Formats = {"elf32-loongarch", "elf32-loongarch",
                                       "elf64-loongarch", "elf64-loongarch"};
   std::array<Triple::ArchType, 4> Archs = {
       Triple::loongarch32, Triple::loongarch32, Triple::loongarch64,
       Triple::loongarch64};
-  size_t I = 0;
-  for (const DataForTest &D : generateData(ELF::EM_LOONGARCH)) {
-    checkFormatAndArch(D, Formats[I], Archs[I]);
-    ++I;
-  }
+  for (auto [Idx, Data] : enumerate(generateData(ELF::EM_LOONGARCH)))
+    checkFormatAndArch(Data, Formats[Idx], Archs[Idx]);
 }
 
 TEST(ELFObjectFileTest, MachineTestForCSKY) {
   std::array<StringRef, 4> Formats = {"elf32-csky", "elf32-csky",
                                       "elf64-unknown", "elf64-unknown"};
-  size_t I = 0;
-  for (const DataForTest &D : generateData(ELF::EM_CSKY))
-    checkFormatAndArch(D, Formats[I++], Triple::csky);
+  for (auto [Idx, Data] : enumerate(generateData(ELF::EM_CSKY)))
+    checkFormatAndArch(Data, Formats[Idx], Triple::csky);
 }
 
 TEST(ELFObjectFileTest, MachineTestForXtensa) {
   std::array<StringRef, 4> Formats = {"elf32-xtensa", "elf32-xtensa",
                                       "elf64-unknown", "elf64-unknown"};
-  size_t I = 0;
-  for (const DataForTest &D : generateData(ELF::EM_XTENSA))
-    checkFormatAndArch(D, Formats[I++], Triple::xtensa);
+  for (auto [Idx, Data] : enumerate(generateData(ELF::EM_XTENSA)))
+    checkFormatAndArch(Data, Formats[Idx], Triple::xtensa);
 }
 
 // ELF relative relocation type test.
 TEST(ELFObjectFileTest, RelativeRelocationTypeTest) {
   EXPECT_EQ(ELF::R_CKCORE_RELATIVE, getELFRelativeRelocationType(ELF::EM_CSKY));
 }
 
 template <class ELFT>