[BOLT][NFC] Use llvm::make_second_range

[rafauler]

bolt/lib/Core/BinaryContext.cpp

1521–1523

Shouldn't this be

llvm::copy(llvm::make_second_range(BinaryFunctions), std::back_inserter(AllFunctions));

like you did in IndirectCallPromotion.cpp? Similarly for other changes.

[Amir]

bolt/lib/Core/BinaryContext.cpp

1521–1523

It can't be a copy. We take a pointer here (&BF), hence transform is needed (that applies a lambda to each element before storing the result).

[rafauler]

Oh I see, there's still a transform going on. Thanks.

[rafauler]

LGTM

bolt/lib/Core/BinaryContext.cpp

 //===----------------------------------------------------------------------===//
 
 #include "bolt/Core/BinaryContext.h"
 #include "bolt/Core/BinaryEmitter.h"
 #include "bolt/Core/BinaryFunction.h"
 #include "bolt/Utils/CommandLineOpts.h"
 #include "bolt/Utils/NameResolver.h"
 #include "bolt/Utils/Utils.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h"
 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
 #include "llvm/MC/MCAsmLayout.h"
 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDisassembler/MCDisassembler.h"
unsigned BinaryContext::addDebugFilenameToUnit(const uint32_t DestCUID,
   assert(FileName != "");
   DWARFCompileUnit *DstUnit = DwCtx->getCompileUnitForOffset(DestCUID);
   return cantFail(getDwarfFile(Dir, FileName, 0, std::nullopt, std::nullopt,
                                DestCUID, DstUnit->getVersion()));
 }
 
 std::vector<BinaryFunction *> BinaryContext::getSortedFunctions() {
   std::vector<BinaryFunction *> SortedFunctions(BinaryFunctions.size());
-  llvm::transform(BinaryFunctions, SortedFunctions.begin(),
-                  [](std::pair<const uint64_t, BinaryFunction> &BFI) {
-                    return &BFI.second;
-                  });
+  llvm::transform(llvm::make_second_range(BinaryFunctions),
+                  SortedFunctions.begin(),
+                  [](BinaryFunction &BF) { return &BF; });
 
   llvm::stable_sort(SortedFunctions,
                     [](const BinaryFunction *A, const BinaryFunction *B) {
                       if (A->hasValidIndex() && B->hasValidIndex()) {
                         return A->getIndex() < B->getIndex();
                       }
                       return A->hasValidIndex();
                     });
   return SortedFunctions;
 }
 
 std::vector<BinaryFunction *> BinaryContext::getAllBinaryFunctions() {
   std::vector<BinaryFunction *> AllFunctions;
   AllFunctions.reserve(BinaryFunctions.size() + InjectedBinaryFunctions.size());
-  llvm::transform(BinaryFunctions, std::back_inserter(AllFunctions),
-                  [](std::pair<const uint64_t, BinaryFunction> &BFI) {
-                    return &BFI.second;
-                  });
+  llvm::transform(llvm::make_second_range(BinaryFunctions),
+                  std::back_inserter(AllFunctions),
+                  [](BinaryFunction &BF) { return &BF; });
   llvm::copy(InjectedBinaryFunctions, std::back_inserter(AllFunctions));
 
   return AllFunctions;
 }
 
 std::optional<DWARFUnit *> BinaryContext::getDWOCU(uint64_t DWOId) {
   auto Iter = DWOCUs.find(DWOId);
   if (Iter == DWOCUs.end())

bolt/lib/Passes/IndirectCallPromotion.cpp

 //===- bolt/Passes/IndirectCallPromotion.cpp ------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the IndirectCallPromotion class.
 //
 //===----------------------------------------------------------------------===//
 
 #include "bolt/Passes/IndirectCallPromotion.h"
 #include "bolt/Passes/BinaryFunctionCallGraph.h"
 #include "bolt/Passes/DataflowInfoManager.h"
 #include "bolt/Passes/Inliner.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/CommandLine.h"
+#include <iterator>
 
 #define DEBUG_TYPE "ICP"
 #define DEBUG_VERBOSE(Level, X)                                                \
   if (opts::Verbosity >= (Level)) {                                            \
     X;                                                                         \
   }
 
 using namespace llvm;
for (const AddressAccess &AccessInfo : MemAccessProfile.AddressAccessInfo) {
     }
 
     std::pair<uint64_t, uint64_t> &HotTarget =
         HotTargetMap[JT->Entries[Index + Range.first]];
     HotTarget.first += AccessInfo.Count;
     HotTarget.second = Index;
   }
 
-  llvm::transform(
-      HotTargetMap, std::back_inserter(HotTargets),
-      [](const std::pair<MCSymbol *, std::pair<uint64_t, uint64_t>> &A) {
-        return A.second;
-      });
+  llvm::copy(llvm::make_second_range(HotTargetMap),
+             std::back_inserter(HotTargets));
 
   // Sort with highest counts first.
   llvm::sort(reverse(HotTargets));
 
   LLVM_DEBUG({
     dbgs() << "BOLT-INFO: ICP jump table hot targets:\n";
     for (const std::pair<uint64_t, uint64_t> &Target : HotTargets)
       dbgs() << "BOLT-INFO:  Idx = " << Target.second << ", "

bolt/lib/Passes/ReorderFunctions.cpp

void ReorderFunctions::runOnFunctions(BinaryContext &BC) {
 
   switch (opts::ReorderFunctions) {
   case RT_NONE:
     break;
   case RT_EXEC_COUNT:
     {
       std::vector<BinaryFunction *> SortedFunctions(BFs.size());
       uint32_t Index = 0;
-      llvm::transform(BFs, SortedFunctions.begin(),
-                      [](std::pair<const uint64_t, BinaryFunction> &BFI) {
-                        return &BFI.second;
-                      });
+      llvm::transform(llvm::make_second_range(BFs), SortedFunctions.begin(),
+                      [](BinaryFunction &BF) { return &BF; });
       llvm::stable_sort(SortedFunctions, [&](const BinaryFunction *A,
                                              const BinaryFunction *B) {
         if (A->isIgnored())
           return false;
         const size_t PadA = opts::padFunction(*A);
         const size_t PadB = opts::padFunction(*B);
         if (!PadA || !PadB) {
           if (PadA)
if (!LinkSectionsFile) {
       errs() << "BOLT-ERROR: link sections file " << opts::LinkSectionsFile
              << " cannot be opened\n";
       exit(1);
     }
   }
 
   if (FuncsFile || LinkSectionsFile) {
     std::vector<BinaryFunction *> SortedFunctions(BFs.size());
-    llvm::transform(BFs, SortedFunctions.begin(),
-                    [](std::pair<const uint64_t, BinaryFunction> &BFI) {
-                      return &BFI.second;
-                    });
+    llvm::transform(llvm::make_second_range(BFs), SortedFunctions.begin(),
+                    [](BinaryFunction &BF) { return &BF; });
 
     // Sort functions by index.
     llvm::stable_sort(SortedFunctions,
                       [](const BinaryFunction *A, const BinaryFunction *B) {
                         if (A->hasValidIndex() && B->hasValidIndex())
                           return A->getIndex() < B->getIndex();
                         if (A->hasValidIndex() && !B->hasValidIndex())
                           return true;

bolt/lib/Rewrite/RewriteInstance.cpp

for (const ELFShdrTy &Section : Sections) {
     // Some sections are stripped
     if (!BinSec->hasValidIndex())
       continue;
 
     NewSectionIndex[OrgIndex] = BinSec->getIndex();
   }
 
   std::vector<ELFShdrTy> SectionsOnly(OutputSections.size());
-  llvm::transform(OutputSections, SectionsOnly.begin(),
-                  [](auto &SectionInfo) { return SectionInfo.second; });
+  llvm::copy(llvm::make_second_range(OutputSections), SectionsOnly.begin());
 
   return SectionsOnly;
 }
 
 // Rewrite section header table inserting new entries as needed. The sections
 // header table size itself may affect the offsets of other sections,
 // so we are placing it at the end of the binary.
 //

bolt/tools/merge-fdata/merge-fdata.cpp

 //===- bolt/tools/merge-fdata/merge-fdata.cpp -----------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Tool for merging profile in fdata format:
 //
 //   $ merge-fdata 1.fdata 2.fdata 3.fdata > merged.fdata
 //
 //===----------------------------------------------------------------------===//
 
 #include "bolt/Profile/ProfileYAMLMapping.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Signals.h"
 #include <unordered_map>
 
int main(int argc, char **argv) {
   }
 
   if (!opts::SuppressMergedDataOutput) {
     yaml::Output YamlOut(output());
 
     BinaryProfile MergedProfile;
     MergedProfile.Header = MergedHeader;
     MergedProfile.Functions.resize(MergedBFs.size());
-    llvm::transform(
-        MergedBFs, MergedProfile.Functions.begin(),
-        [](StringMapEntry<BinaryFunctionProfile> &V) { return V.second; });
+    llvm::copy(llvm::make_second_range(MergedBFs),
+               MergedProfile.Functions.begin());
 
     // For consistency, sort functions by their IDs.
     llvm::sort(MergedProfile.Functions,
                [](const BinaryFunctionProfile &A,
                   const BinaryFunctionProfile &B) { return A.Id < B.Id; });
 
     YamlOut << MergedProfile;
   }