[ELF] - Replace parallelForEach with ranged form.

[grimar]

Summary

Makes code a bit more convinent to write/read.

[ruiu]

I'm sort of neutral to this change, so if you prefer this style, go for it.

ELF/Threads.h

70

Why auto?

[grimar]

• Fixed misprint auto -> void

[ruiu]

I wouldn't request you revert this, but if I were you, I wouldn't have commit this change, because as we discussed, this change contains subtle code that seems only language experts can understand. I don't think it is overall beneficial to save a few lines of code by writing very "smart" code here.

ELF/SyntheticSections.cpp

 // sections to create mergeable synthetic sections. It removes
 // MergeInputSections from the input section array and adds new synthetic
 // sections at the location of the first input section that it replaces. It then
 // finalizes each synthetic section in order to compute an output offset for
 // each piece of each input section.
 void elf::decompressAndMergeSections() {
   // splitIntoPieces needs to be called on each MergeInputSection before calling
   // finalizeContents(). Do that first.
-  parallelForEach(InputSections.begin(), InputSections.end(),
-                  [](InputSectionBase *S) {
-                    if (!S->Live)
-                      return;
-                    if (Decompressor::isCompressedELFSection(S->Flags, S->Name))
-                      S->uncompress();
-                    if (auto *MS = dyn_cast<MergeInputSection>(S))
-                      MS->splitIntoPieces();
-                  });
+  parallelForEach(InputSections, [](InputSectionBase *S) {
 
   std::vector<MergeSyntheticSection *> MergeSections;
   for (InputSectionBase *&S : InputSections) {
     MergeInputSection *MS = dyn_cast<MergeInputSection>(S);
     if (!MS)
       continue;
 
     // We do not want to handle sections that are not alive, so just remove

ELF/Threads.h

 #include "Config.h"
 
 #include "llvm/Support/Parallel.h"
 #include <functional>
 
 namespace lld {
 namespace elf {
 
-template <class IterTy, class FuncTy>
-void parallelForEach(IterTy Begin, IterTy End, FuncTy Fn) {
+template <typename R, class FuncTy> void parallelForEach(R &&Range, FuncTy Fn) {
   if (Config->Threads)
-    for_each(llvm::parallel::par, Begin, End, Fn);
+    for_each(llvm::parallel::par, std::begin(Range), std::end(Range), Fn);
   else
-    for_each(llvm::parallel::seq, Begin, End, Fn);
+    for_each(llvm::parallel::seq, std::begin(Range), std::end(Range), Fn);
 }
 
 inline void parallelForEachN(size_t Begin, size_t End,
                              std::function<void(size_t)> Fn) {
   if (Config->Threads)
     for_each_n(llvm::parallel::par, Begin, End, Fn);
   else
     for_each_n(llvm::parallel::seq, Begin, End, Fn);
 }
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/Writer.cpp

if (ErrorCount)
     return;
 
   if (!Script->Opt.HasSections && !Config->Relocatable)
     fixSectionAlignments();
 
   // If -compressed-debug-sections is specified, we need to compress
   // .debug_* sections. Do it right now because it changes the size of
   // output sections.
-  parallelForEach(OutputSections.begin(), OutputSections.end(),
+  parallelForEach(OutputSections,
                   [](OutputSection *Sec) { Sec->maybeCompress<ELFT>(); });
 
   Script->assignAddresses();
   Script->allocateHeaders(Phdrs);
 
   // Remove empty PT_LOAD to avoid causing the dynamic linker to try to mmap a
   // 0 sized region. This has to be done late since only after assignAddresses
   // we know the size of the sections.