[COFF] ICF: use parallelForEach{,N}

[MaskRay]

Summary

They have an additional ThreadsEnabled check, which does not matter much.

[MaskRay]

swap include order

[ruiu]

We assume that threads are always available on Windows, and we don't provide an option to the user to disable multi-threading, so this change is basically a no-op. That said, I'd like to see this to land for the sake of consistency. LGTM.

COFF/ICF.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "ICF.h"
 #include "Chunks.h"
 #include "Symbols.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Timer.h"
+#include "lld/Common/Threads.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Parallel.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/xxhash.h"
 #include <algorithm>
 #include <atomic>
 #include <vector>
void ICF::forEachClass(std::function<void(size_t, size_t)> Fn) {
   // The sharding must be completed before any calls to Fn are made
   // so that Fn can modify the Chunks in its shard without causing data
   // races.
   const size_t NumShards = 256;
   size_t Step = Chunks.size() / NumShards;
   size_t Boundaries[NumShards + 1];
   Boundaries[0] = 0;
   Boundaries[NumShards] = Chunks.size();
-  for_each_n(parallel::par, size_t(1), NumShards, [&](size_t I) {
+  parallelForEachN(1, NumShards, [&](size_t I) {
     Boundaries[I] = findBoundary((I - 1) * Step, Chunks.size());
   });
-  for_each_n(parallel::par, size_t(1), NumShards + 1, [&](size_t I) {
+  parallelForEachN(1, NumShards + 1, [&](size_t I) {
     if (Boundaries[I - 1] < Boundaries[I]) {
       forEachClassRange(Boundaries[I - 1], Boundaries[I], Fn);
     }
   });
   ++Cnt;
 }
 
 // Merge identical COMDAT sections.
void ICF::run(ArrayRef<Chunk *> Vec) {
 
   // Make sure that ICF doesn't merge sections that are being handled by string
   // tail merging.
   for (auto &P : MergeChunk::Instances)
     for (SectionChunk *SC : P.second->Sections)
       SC->Class[0] = NextId++;
 
   // Initially, we use hash values to partition sections.
-  for_each(parallel::par, Chunks.begin(), Chunks.end(), [&](SectionChunk *SC) {
+  parallelForEach(Chunks, [&](SectionChunk *SC) {
     SC->Class[1] = xxHash64(SC->getContents());
   });
 
   // Combine the hashes of the sections referenced by each section into its
   // hash.
-  for_each(parallel::par, Chunks.begin(), Chunks.end(), [&](SectionChunk *SC) {
+  parallelForEach(Chunks, [&](SectionChunk *SC) {
     uint32_t Hash = SC->Class[1];
     for (Symbol *B : SC->symbols())
       if (auto *Sym = dyn_cast_or_null<DefinedRegular>(B))
         Hash ^= Sym->getChunk()->Class[1];
     // Set MSB to 1 to avoid collisions with non-hash classs.
     SC->Class[0] = Hash | (1U << 31);
   });