[lld][COFF][ELF][WebAssembly] Replace --[no-]threads /threads[:no] with --threads={1,2,...} /threads:{1,2,...}

[MaskRay]

Summary

--no-threads is a name copied from gold.
gold has --no-thread, --thread-count and several other --thread-count-*.

There are needs to customize the number of threads (running several lld
processes concurrently or customizing the number of LTO threads).
Having a single --threads=N is a straightforward replacement of gold's
--no-threads + --thread-count.

--no-threads is used rarely. So just delete --no-threads instead of
keeping it for compatibility for a while.

If --threads= is specified (ELF,wasm; COFF /threads: is similar),
--thinlto-jobs= defaults to --threads=,
otherwise all available hardware threads are used.

There is currently no way to override a --threads={1,2,...}. It is still
a debate whether we should use --threads=all.

[MaskRay]

Don't move threads in wasm/Options.td

[MaskRay]

Fix COFF/Driver.cpp

[sbc100]

I do use --no-threads fairly often when debugging (so that trace output is not interleaved).. but I can learn to type it as --threads=1.

[grimar]

lld/wasm/Options.td

98–100

I'd probably expect to see a behavior when with --threads==0 we either report error or just disable multithreading (i.e. threads==0 == threads==1)? Perhaps the default could be -1.

[MaskRay]

lld/wasm/Options.td

98–100

@aganea There is a debate about 0 vs -1. What's your opinion?

[aganea]

lld/wasm/Options.td

98–100

@grimar There's a subtlety there. If the code uses the std::heavyweight_hardware_concurrency() strategy, that means we should create a single std::thread per hardware core. That function is used in ThinLTO for example.

Not having --threads=... on the cmd-line, or --threads=0, lets the code decide (either std::heavyweight_hardware_concurrency() or std::hardware_concurrency())

--threads=N or --threads=all will always fallback to plain std::hardware_concurrency() strategy, which means to use all hardware threads (SMT or CMT). Typically, this mode is used when linking a large monolithic program.

Perhaps we could change to --threads=[no|0|1] to disable multi-threading, and let the task execute on the main thread (for debugging). Please see the definition for llvm::get_threadpool_strategy().

[aganea]

lld/wasm/Options.td

98–100

@MaskRay I feel both 0 and -1 are not user-friendly. I think it is better to say what we mean, --threads=no or --threads=default. But to follow the principle of least astonishment, --threads=0 or --threads=1 could disable multi-threading. WDYT?

[MaskRay]

Default to --threads=all
Default --thinlto-jobs= to --threads=
Disallow --threads=0 and --threads=-1

[sbc100]

lld/wasm/Driver.cpp

387

Just, FYI, if there is sufficient code shared with the ELF linker there we do have Common/Args.h as a place to share common arg processing code.

[MaskRay]

lld/wasm/Driver.cpp

387

I know Common/Args.h. OPT_threads and config are of different types in ELF and in wasm, so sharing may not simplify the code.

[aganea]

lld/COFF/Driver.cpp

1147–1157

This is not consistent with the ELF part. The cmd-line flags grammar and the handling should the be similar.

lld/Common/Threads.cpp

0

Make this ThreadPoolStrategy parallel::Strategy; and move to llvm/lib/Support/Parallel.[h|cpp], and use in Executor::getDefaultExecutor() when constructing the ThreadPoolExecutor.

Otherwise --threads=N will have no effect on the functions used by lld/Common/Threads.h.

lld/ELF/Driver.cpp

1040

What about doing this instead:

config->thinLTOJobs = args.getLastArgValue(OPT_thinlto_jobs);

if (auto *arg = args.getLastArg(OPT_threads)) {
  auto S = get_threadpool_strategy(arg->getValue());
  if (!S)
    error("--threads: invalid thread count: " + arg->getValue());
  parallel::Strategy = *S;

  // maybe warn if --thinlto-jobs= is provided along with --threads=
  config->thinLTOJobs = arg->getValue();
}

This makes for consistent behavior for any of the thread-count flags: --threads, /opt:lldltojobs=, -flto-jobs=, --thinlto-jobs=, -thinlto-threads=, --plugin-opt=jobs=.

And that way, we could uniformly extend the cmd-line flags grammar, if need be (for example if we want platform-independent takset/NUMA control). See @ikitayama 's issue: http://lists.llvm.org/pipermail/llvm-dev/2020-March/140432.html

lld/ELF/SyntheticSections.cpp

2753–2754

I realized the algorithm below didn't make sense if concurrency is not a power-of-two (including 2^0 when multi-threading is disabled/off).

Could you please rebase on rG42dc667db248e27a44dc245d5c39ce1f8ad26a85 -- reverted a mistake I did.

3195–3196

if (parallel::Strategy.ThreadsRequested != 1)

lld/include/lld/Common/Threads.h

66

Remove (see first comment).

68

if (parallel::Strategy.ThreadsRequested != 1)

75

Ditto.

lld/wasm/Driver.cpp

380

Same comment as for the ELF part.

[MaskRay]

Address review comments

[MaskRay]

lld/Common/Threads.cpp

0

I only intended to change the option name, but now it is clear that doing that will cause a future rename churn (enabledThreads -> llvm::parallel::strategy). Let's just finish it with one patch.

lld/ELF/Driver.cpp

1040

get_threadpool_strategy interprets 0 differently from lld (your previous suggestion is that we should error), and "" differently (lld probably should reject an empty string).

If this takes time to get a consensus, we can make this change separately.

lld/ELF/SyntheticSections.cpp

2753–2754

This explained an internal failure I saw. I "fixed" that with 34bdddf9a13cfdbbb5506dc89cf8e781be53105f.

Though I have touched this piece of code several times. I forgot there was a bug after your previous change..

3195–3196

I'll simplify it further.

[MaskRay]

Some adjustment

[MaskRay]

Fix ELF/SyntheticSections.cpp

[grimar]

lld/test/ELF/threads.test

1 ↗

(On Diff #253502)

llvm-mc /dev/null -o %t.o -filetype=obj -triple=xxx?

(the same for the wasm test)

12 ↗

(On Diff #253502)

Perhaps use FileCheck -DVAL=xxx to make checks explicit?

[aganea]

lld/ELF/Driver.cpp

1040

In that case, I would modify get_threadpool_strategy. This function was only added recently, and I'm not fond of =0, we can error out in that case in get_threadpool_strategy, to match what was discussed so far. I would prefer matching behavior for all thread flags across LLVM. But yes, we can do after if you prefer.

llvm/lib/Support/Parallel.cpp

23

llvm::parallel::Strategy. LLVM uses first letter uppercase for variables, whereas LLD uses lowercase.

[MaskRay]

Address comments

lld/ELF/Driver.cpp

1040

If we delete "" and "0" cases from get_threadpool_strategy, then there will be no way to return the default value. This probably means get_threadpool_strategy does not meed lld's needs without an API change. We can defer the change.

llvm/lib/Support/Parallel.cpp

23

llvm::parallel::{seq,par} are lower cased variables. I think this should not matter.

[aganea]

llvm/lib/Support/Parallel.cpp

142

Do you think you can move this inside the ThreadPoolExecutor class, like ThreadPoolExecutor::Deleter?

[MaskRay]

Move a function local Creator to ThreadPoolExecutor::Creator

[aganea]

Thanks for the quick changes! Just a few more things and I think it should be good to go.

lld/COFF/Driver.cpp

1156

nit: use parallel::strategy = hardware_concurrency(threads); to ensure any future change to the default strategy does not change this behavior (same comment for other places below).

1157

Overwrite config->thinLTOJobs here, like the ELF part.

lld/COFF/Options.td

223

"Number of threads. 'all' (default) means all of concurrent threads supported. '1' disables multi-threading."

Same comment for the other drivers.

lld/ELF/Driver.cpp

1047

In absolute terms, do we really need two options for setting multi-threading? (-threads= for general-purpose code, and -thinlto-jobs= for ThinLTO threads)
We can address this later, but it might complicate the setup for users. @tejohnson

llvm/lib/Support/Parallel.cpp

23

Please add a comment above signifying that this defaults to using all hardware threads.

[MaskRay]

Address review comments

lld/ELF/Driver.cpp

1047

I had the same question:) I think even if people start to migrate to --threads, -thinlto-jobs= may be useful for debugging ThinLTO issues. --thinlto-jobs=1 can be used together with --save-temps, without slowding down other parallel loops. Whether this is worth a separate option needs more thoughts.

[aganea]

LGTM, thanks! Maybe wait a bit in case there are other comments.

Some todos for the record:

• This line: https://github.com/llvm/llvm-project/blob/master/lld/lib/ReaderWriter/MachO/LayoutPass.cpp#L464 - should use the parallelSort() API, but could be done later.
• parallel::strategy.ThreadsRequested == 1 is a bit verbose and error prone, it could be an API like parallel::strategy.useThreads() - this could be done in a subsequent commit.
• Is there value for the code in lld/Common/Threads.h? It could be replaced with direct calls to Parallel.h APIs instead? (assuming they handle the "no multi-threading" case)
• Same function for handling --threads= in all three drivers and get_threadpool_strategy().

[rnk]

lgtm

Thanks @aganea for reviewing. I didn't review thoroughly, but I approve of the direction.

[MaskRay]

Thanks @aganea for reviewing and a list of TODO items in https://reviews.llvm.org/D76885#1950989 , and @rnk.

Add .Cm 1 disables multi-threading to docs/ld.lld.1
Fix a comment --thinlto-jobs= -> /opt:lldltojobs= in COFF/Driver.cpp

Will wait a bit and see if there are other comments.

[ruiu]

Do we need all? It's the default behavior, so if you want to specify --threads=all, you can just delete it altogether.

Are you going to make the same change for the other ports? I think wasm-ld mimics GNU linker's options, and I don't think we want to deviate too much from it, even if it simplifies the command line options.

[MaskRay]

In D76885#1951634, @ruiu wrote:

Do we need all? It's the default behavior, so if you want to specify --threads=all, you can just delete it altogether.

--threads=all is a way to override a previous --threads=3. We just need a way to reset the behavior to a previous state. It is just for completeness.

Are you going to make the same change for the other ports? I think wasm-ld mimics GNU linker's options, and I don't think we want to deviate too much from it, even if it simplifies the command line options.

--threads and --no-threads are gold-only options. They have currently mostly debug options. GNU ld does not have it. gold actually has more options but they are probably overkill:

--thread-count COUNT
       Number of threads to use

--thread-count-initial COUNT
       Number of threads to use in initial pass

--thread-count-middle COUNT Number of threads to use in middle pass

--thread-count-final COUNT
       Number of threads to use in final pass

For wasm-ld, @sbc100 mentioned that he can change his habit to adapt the new --threads=

[ruiu]

Instead of --threads=all, can you use --threads? --threads has several advantages over --threads=all:

• it is consistent with other command such as make, which takes -j for "all" and -jN for N threads
• it is compatible with gold
• "all" isn't technically very accurate. A more accurate option name would be something like --threads=same-as-cpu-threads, but that's fringe. By eliminating an argument, we can avoid naming it.

If we are doing this, I'd like to see this to be added to the ELF version.

[MaskRay]

In D76885#1951714, @ruiu wrote:

Instead of --threads=all, can you use --threads? --threads has several advantages over --threads=all:

• it is consistent with other command such as make, which takes -j for "all" and -jN for N threads
• it is compatible with gold
• "all" isn't technically very accurate. A more accurate option name would be something like --threads=same-as-cpu-threads, but that's fringe. By eliminating an argument, we can avoid naming it.

If we are doing this, I'd like to see this to be added to the ELF version.

Nobody uses --threads. I will delete --threads=all. Let's wait for other opinion whether we need an options restoring the default behavior.

One argument for --threads=all is that --thinlto-jobs=all is supported, but this point will be moot if we are going to revisit it.

[MaskRay]

Delete --threads=all

[MaskRay]

Update description

[sbc100]

In D76885#1951714, @ruiu wrote:

Instead of --threads=all, can you use --threads? --threads has several advantages over --threads=all:

• it is consistent with other command such as make, which takes -j for "all" and -jN for N threads

I don't disagree with your arguments but from the man page it looks like make -j without any args means there is no upper limit at all:

j [jobs], --jobs[=jobs]
            Specifies  the  number of jobs (commands) to run simultaneously.  If there is more than one -j option, the last one
            is effective.  If the -j option is given without an argument, make will not limit the number of jobs that  can  run
            simultaneously.

Unless I'm misreading. I guess that is why we very rarely see it in the wild.

• it is compatible with gold
• "all" isn't technically very accurate. A more accurate option name would be something like --threads=same-as-cpu-threads, but that's fringe. By eliminating an argument, we can avoid naming it.

If we are doing this, I'd like to see this to be added to the ELF version.

[MaskRay]

Just a quick question to bounce on what Rui said: why not make this flag -j instead of --threads? Everyone is indeed used to -j. Is there an argument for it being --threads?

@aganea make/ninja/parallel spawn processes (jobs). For an ld, its has a single job. --threads= might be a bit implementation specific but I cannot think of a better term expression parallelism within a job...

There is another very weak argument. Because j is a prefix of just-symbols, GNU style getopt_long treats -j as an abbreviation of --just-symbols (which is implemented along with -rpath). If we add -j to lld, it can do different things from GNU ld. This makes a short option -j less favorable...

[broadwaylamb]

It looks like this change broke our buildbot: http://lab.llvm.org:8011/builders/llvm-clang-win-x-armv7l/builds/6358

Could you please recommit this with a fix, or revert this?

[broadwaylamb]

lld/test/ELF/threads.s

1

This bot builds a cross-toolchain that can only produce binaries for ARM, so this test fails because it only supports x86_64. Maybe you can mark it as unsupported?

[MaskRay]

lld/test/ELF/threads.s

1

Added in commit 0f44a09757f4f45e527e2bb79f15eb16967457a1

[broadwaylamb]

lld/test/ELF/threads.s

1

The failure is gone, thanks!

[smeenai]

This comment was removed by smeenai.

[smeenai]

For people who were using -Wl,--no-threads to disable parallelism in (some parts of) their build system, what's the way forward if they want to support both older and newer LLD versions?

(I suppose feature flag detection is one way, but that's not really a thing on some build systems, including Bazel, I believe.)

[MaskRay]

In D76885#1955404, @smeenai wrote:

For people who were using -Wl,--no-threads to disable parallelism in (some parts of) their build system, what's the way forward if they want to support both older and newer LLD versions?

(I suppose feature flag detection is one way, but that's not really a thing on some build systems, including Bazel, I believe.)

-Wl,--no-threads should be very rare. https://github.com/halide/Halide/blob/master/src/runtime/hexagon_remote/Makefile and libsodium_1.0.18-1/dist-build/wasm32-wasi.sh are the only open source cases I can find. You probably should make the change while bumping the version of lld.

[phosek]

In D76885#1952633, @MaskRay wrote:

In D76885#1951714, @ruiu wrote:

Instead of --threads=all, can you use --threads? --threads has several advantages over --threads=all:

• it is consistent with other command such as make, which takes -j for "all" and -jN for N threads
• it is compatible with gold
• "all" isn't technically very accurate. A more accurate option name would be something like --threads=same-as-cpu-threads, but that's fringe. By eliminating an argument, we can avoid naming it.

If we are doing this, I'd like to see this to be added to the ELF version.

Nobody uses --threads. I will delete --threads=all. Let's wait for other opinion whether we need an options restoring the default behavior.

I disagree, we've been using --threads for some time (there are 5 different instances of this flag just in the Fuchsia build, see for example https://fuchsia.googlesource.com/fuchsia/+/refs/heads/master/build/config/fuchsia/BUILD.gn#48) and this change broke our build.

One argument for --threads=all is that --thinlto-jobs=all is supported, but this point will be moot if we are going to revisit it.

[phosek]

I think the removal of --thread could have been handled more gracefully, e.g. print a warning but retain the existing functionality, and later follow up with the removal. Right now our only options are to either disable threading until we roll the new toolchain and slow down the build in the meantime, or disable the canary bots and loose coverage for upstream changes, neither of which is great.

[sbc100]

In D76885#1955969, @phosek wrote:

I think the removal of --thread could have been handled more gracefully, e.g. print a warning but retain the existing functionality, and later follow up with the removal. Right now our only options are to either disable threading until we roll the new toolchain and slow down the build in the meantime, or disable the canary bots and loose coverage for upstream changes, neither of which is great.

I tend to agree. I think the assumption was that this was only used by developers to debug (at least that was my only use for it). I think you have proved that assumption wrong.

[MaskRay]

In D76885#1955969, @phosek wrote:

I think the removal of --thread could have been handled more gracefully, e.g. print a warning but retain the existing functionality, and later follow up with the removal. Right now our only options are to either disable threading until we roll the new toolchain and slow down the build in the meantime, or disable the canary bots and loose coverage for upstream changes, neither of which is great.

--threads was the default so you can just delete it from your BUILD.gn There is no functional difference before or after this change.

[dmajor]

This commit breaks the build when -DLLVM_ENABLE_THREADS=OFF is used. Could you please take a look?

Undefined symbols for architecture x86_64:
  "llvm::parallel::strategy", referenced from:
      readConfigs(llvm::opt::InputArgList&) in liblldELF.a(Driver.cpp.o)
      lld::coff::LinkerDriver::link(llvm::ArrayRef<char const*>) in liblldCOFF.a(Driver.cpp.o)
      lld::wasm::(anonymous namespace)::LinkerDriver::link(llvm::ArrayRef<char const*>) in liblldWasm.a(Driver.cpp.o)
      lld::unlinkAsync(llvm::StringRef) in liblldCommon.a(Filesystem.cpp.o)
      lld::elf::MergeNoTailSection::finalizeContents() in liblldELF.a(SyntheticSections.cpp.o)
      createSymbols(llvm::ArrayRef<std::__1::vector<lld::elf::GdbIndexSection::NameAttrEntry, std::__1::allocator<lld::elf::GdbIndexSection::NameAttrEntry> > >, std::__1::vector<lld::elf::GdbIndexSection::GdbChunk, std::__1::allocator<lld::elf::GdbIndexSection::GdbChunk> > const&) in liblldELF.a(SyntheticSections.cpp.o)
      void lld::elf::doIcf<llvm::object::ELFType<(llvm::support::endianness)1, false> >() in liblldELF.a(ICF.cpp.o)
      ...

[dmajor]

I filed https://bugs.llvm.org/show_bug.cgi?id=46641 to make sure it doesn't get lost.

[dmajor]

--no-threads is used rarely. So just delete --no-threads instead of keeping it for compatibility for a while.

I encountered a frustrating issue with seemingly-unrelated symptoms that eventually traced back to this change.

The wasi-sdk project was building libcxx, and its build system had set CMAKE_EXE_LINKER_FLAGS="-Wl,--no-threads" (I don't know why, wasi-sdk is an unfamiliar project to me, I just needed to build it for something else). When cmake was doing its usual "is XYZ supported" tests, the --no-threads option caused the checks to fail, so cmake believed that for example LIBCXX_SUPPORTS_FNO_EXCEPTIONS_FLAG was false. But the cmake was overall still successful. So we got an apparently successful libcxx build but it didn't have the settings that were requested. This manifested as weird issues in a faraway place later. It took a lot of time to track down.

It's not clear to me why the --no-threads made the "is XYZ supported" checks fail but the actual build still succeeded. I'm pretty worried though about introducing this kind of silent behavior change. Do you think other projects may be susceptible to such a problem? Should the lack of --no-threads compatibility be reconsidered for the 11 release branch?

[sbc100]

In D76885#2194272, @dmajor wrote:

--no-threads is used rarely. So just delete --no-threads instead of keeping it for compatibility for a while.

I encountered a frustrating issue with seemingly-unrelated symptoms that eventually traced back to this change.

The wasi-sdk project was building libcxx, and its build system had set CMAKE_EXE_LINKER_FLAGS="-Wl,--no-threads" (I don't know why, wasi-sdk is an unfamiliar project to me, I just needed to build it for something else). When cmake was doing its usual "is XYZ supported" tests, the --no-threads option caused the checks to fail, so cmake believed that for example LIBCXX_SUPPORTS_FNO_EXCEPTIONS_FLAG was false. But the cmake was overall still successful. So we got an apparently successful libcxx build but it didn't have the settings that were requested. This manifested as weird issues in a faraway place later. It took a lot of time to track down.

It's not clear to me why the --no-threads made the "is XYZ supported" checks fail but the actual build still succeeded. I'm pretty worried though about introducing this kind of silent behavior change. Do you think other projects may be susceptible to such a problem? Should the lack of --no-threads compatibility be reconsidered for the 11 release branch?

Regardless of what we decide to do here.. we should remove that flag from wasi-sdk build system. I have no idea why it was added, perhaps there were some bugs related to threading early on in the development of wasm-ld and this just never got removed.

[MaskRay]

In D76885#2194272, @dmajor wrote:

--no-threads is used rarely. So just delete --no-threads instead of keeping it for compatibility for a while.

I encountered a frustrating issue with seemingly-unrelated symptoms that eventually traced back to this change.

The wasi-sdk project was building libcxx, and its build system had set CMAKE_EXE_LINKER_FLAGS="-Wl,--no-threads" (I don't know why, wasi-sdk is an unfamiliar project to me, I just needed to build it for something else). When cmake was doing its usual "is XYZ supported" tests, the --no-threads option caused the checks to fail, so cmake believed that for example LIBCXX_SUPPORTS_FNO_EXCEPTIONS_FLAG was false. But the cmake was overall still successful. So we got an apparently successful libcxx build but it didn't have the settings that were requested. This manifested as weird issues in a faraway place later. It took a lot of time to track down.

It's not clear to me why the --no-threads made the "is XYZ supported" checks fail but the actual build still succeeded. I'm pretty worried though about introducing this kind of silent behavior change. Do you think other projects may be susceptible to such a problem? Should the lack of --no-threads compatibility be reconsidered for the 11 release branch?

Sam is the code owner of the WebAssembly backend. He makes the decision whether --no-threads needs to be supported.

Personally I recognize that the removal of the option caused some friction but (at least for COFF/ELF) I don't think the use cases are critical enough to be supported.

[sbc100]

In D76885#2194339, @MaskRay wrote:

In D76885#2194272, @dmajor wrote:

--no-threads is used rarely. So just delete --no-threads instead of keeping it for compatibility for a while.

I encountered a frustrating issue with seemingly-unrelated symptoms that eventually traced back to this change.

The wasi-sdk project was building libcxx, and its build system had set CMAKE_EXE_LINKER_FLAGS="-Wl,--no-threads" (I don't know why, wasi-sdk is an unfamiliar project to me, I just needed to build it for something else). When cmake was doing its usual "is XYZ supported" tests, the --no-threads option caused the checks to fail, so cmake believed that for example LIBCXX_SUPPORTS_FNO_EXCEPTIONS_FLAG was false. But the cmake was overall still successful. So we got an apparently successful libcxx build but it didn't have the settings that were requested. This manifested as weird issues in a faraway place later. It took a lot of time to track down.

It's not clear to me why the --no-threads made the "is XYZ supported" checks fail but the actual build still succeeded. I'm pretty worried though about introducing this kind of silent behavior change. Do you think other projects may be susceptible to such a problem? Should the lack of --no-threads compatibility be reconsidered for the 11 release branch?

Sam is the code owner of the WebAssembly backend. He makes the decision whether --no-threads needs to be supported.

Personally I recognize that the removal of the option caused some friction but (at least for COFF/ELF) I don't think the use cases are critical enough to be supported.

I'm OK with fixing this downstream in this case I think. There should be very few users of this flag with wasm-ld but also I wouldn't want the flag names for the same feature to be different between different lld backends.

In terms of the way this problem manifested, It makes sense that the cmake feature detection would fail because it wouldn't be able to link any of the test programs it was building. I imagine the overall project still built because there are no executables in this case, only libraries, so there is no link step in the build, only llvm-ar. For most projects this wouldn't be and issue and they would see a clear link failure.

[sunfish]

I've now opened https://github.com/WebAssembly/wasi-sdk/pull/151/ to remove the --no-threads from wasi-sdk, which was a workaround for an old bug that has long been fixed.

[sbc100]

Jinx: https://github.com/WebAssembly/wasi-sdk/pull/150

[dmajor]

In D76885#2194387, @sunfish wrote:

I've now opened https://github.com/WebAssembly/wasi-sdk/pull/151/ to remove the --no-threads from wasi-sdk, which was a workaround for an old bug that has long been fixed.

With that PR now merged, I've confirmed that the latest wasi-sdk tree no longer hits the issue I was seeing. Thanks everyone.

lld/COFF/Driver.cpp

void LinkerDriver::link(ArrayRef<const char *> argsArr) {
   }
 
   // Handle /help
   if (args.hasArg(OPT_help)) {
     printHelp(argsArr[0]);
     return;
   }
 
-  lld::threadsEnabled = args.hasFlag(OPT_threads, OPT_threads_no, true);
+  // /threads: takes a positive integer and provides the default value for
+  // /opt:lldltojobs=.
+  if (auto *arg = args.getLastArg(OPT_threads)) {
+    StringRef v(arg->getValue());
+    unsigned threads = 0;
+    if (!llvm::to_integer(v, threads, 0) || threads == 0)
+      error(arg->getSpelling() + ": expected a positive integer, but got '" +
+            arg->getValue() + "'");
+    parallel::strategy = hardware_concurrency(threads);
+    config->thinLTOJobs = v.str();
+  }
 
   if (args.hasArg(OPT_show_timing))
     config->showTiming = true;
 
   config->showSummary = args.hasArg(OPT_summary);
 
   ScopedTimer t(Timer::root());
   // Handle --version, which is an lld extension. This option is a bit odd

lld/COFF/Options.td

 def thinlto_prefix_replace: P<
     "thinlto-prefix-replace",
     "'old;new' replace old prefix with new prefix in ThinLTO outputs">;
 def lto_obj_path : P<
     "lto-obj-path",
     "output native object for merged LTO unit to this path">;
 def dash_dash_version : Flag<["--"], "version">,
   HelpText<"Print version information">;
-defm threads: B<"threads",
-    "Run the linker multi-threaded (default)",
-    "Do not run the linker multi-threaded">;
+def threads
+    : P<"threads", "Number of threads. '1' disables multi-threading. By "
+                   "default all available hardware threads are used">;
 
 // Flags for debugging
 def lldmap : F<"lldmap">;
 def lldmap_file : Joined<["/", "-", "/?", "-?"], "lldmap:">;
 def map : F<"map">;
 def map_file : Joined<["/", "-", "/?", "-?"], "map:">;
 def show_timing : F<"time">;
 def summary : F<"summary">;

lld/Common/CMakeLists.txt

add_lld_library(lldCommon
   Args.cpp
   DWARF.cpp
   ErrorHandler.cpp
   Filesystem.cpp
   Memory.cpp
   Reproduce.cpp
   Strings.cpp
   TargetOptionsCommandFlags.cpp
-  Threads.cpp
   Timer.cpp
   VCSVersion.inc
   Version.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLD_INCLUDE_DIR}/lld/Common
 
   LINK_COMPONENTS

lld/Common/Filesystem.cpp

 //
 // This function spawns a background thread to remove the file.
 // The calling thread returns almost immediately.
 void lld::unlinkAsync(StringRef path) {
 // Removing a file is async on windows.
 #if defined(_WIN32)
   sys::fs::remove(path);
 #else
-  if (!threadsEnabled || !sys::fs::exists(path) ||
+  if (parallel::strategy.ThreadsRequested == 1 || !sys::fs::exists(path) ||
       !sys::fs::is_regular_file(path))
     return;
 
   // We cannot just remove path from a different thread because we are now going
   // to create path as a new file.
   // Instead we open the file and unlink it on this thread. The unlink is fast
   // since the open fd guarantees that it is not removing the last reference.
   int fd;

lld/Common/Threads.cpp

-//===- Threads.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
-//
-//===----------------------------------------------------------------------===//
-
-#include "lld/Common/Threads.h"
-
-bool lld::threadsEnabled = true;

lld/ELF/Driver.cpp

 
 // Initializes Config members by the command line options.
 static void readConfigs(opt::InputArgList &args) {
   errorHandler().verbose = args.hasArg(OPT_verbose);
   errorHandler().fatalWarnings =
       args.hasFlag(OPT_fatal_warnings, OPT_no_fatal_warnings, false);
   errorHandler().vsDiagnostics =
       args.hasArg(OPT_visual_studio_diagnostics_format, false);
-  threadsEnabled = args.hasFlag(OPT_threads, OPT_no_threads, true);
 
   config->allowMultipleDefinition =
       args.hasFlag(OPT_allow_multiple_definition,
                    OPT_no_allow_multiple_definition, false) ||
       hasZOption(args, "muldefs");
   config->allowShlibUndefined =
       args.hasFlag(OPT_allow_shlib_undefined, OPT_no_allow_shlib_undefined,
                    args.hasArg(OPT_shared));
static void readConfigs(opt::InputArgList &args) {
   config->thinLTOCacheDir = args.getLastArgValue(OPT_thinlto_cache_dir);
   config->thinLTOCachePolicy = CHECK(
       parseCachePruningPolicy(args.getLastArgValue(OPT_thinlto_cache_policy)),
       "--thinlto-cache-policy: invalid cache policy");
   config->thinLTOEmitImportsFiles = args.hasArg(OPT_thinlto_emit_imports_files);
   config->thinLTOIndexOnly = args.hasArg(OPT_thinlto_index_only) ||
                              args.hasArg(OPT_thinlto_index_only_eq);
   config->thinLTOIndexOnlyArg = args.getLastArgValue(OPT_thinlto_index_only_eq);
-  config->thinLTOJobs = args.getLastArgValue(OPT_thinlto_jobs);
   config->thinLTOObjectSuffixReplace =
       getOldNewOptions(args, OPT_thinlto_object_suffix_replace_eq);
   config->thinLTOPrefixReplace =
       getOldNewOptions(args, OPT_thinlto_prefix_replace_eq);
   config->timeTraceEnabled = args.hasArg(OPT_time_trace);
   config->timeTraceGranularity =
       args::getInteger(args, OPT_time_trace_granularity, 500);
   config->trace = args.hasArg(OPT_trace);
static void readConfigs(opt::InputArgList &args) {
 
   for (auto *arg : args.filtered(OPT_plugin_opt))
     parseClangOption(arg->getValue(), arg->getSpelling());
 
   // Parse -mllvm options.
   for (auto *arg : args.filtered(OPT_mllvm))
     parseClangOption(arg->getValue(), arg->getSpelling());
 
+  // --threads= takes a positive integer and provides the default value for
+  // --thinlto-jobs=.
+  if (auto *arg = args.getLastArg(OPT_threads)) {
+    StringRef v(arg->getValue());
+    unsigned threads = 0;
+    if (!llvm::to_integer(v, threads, 0) || threads == 0)
+      error(arg->getSpelling() + ": expected a positive integer, but got '" +
+            arg->getValue() + "'");
+    parallel::strategy = hardware_concurrency(threads);
+    config->thinLTOJobs = v;
+  }
+  if (auto *arg = args.getLastArg(OPT_thinlto_jobs))
+    config->thinLTOJobs = arg->getValue();
+
   if (config->ltoo > 3)
     error("invalid optimization level for LTO: " + Twine(config->ltoo));
   if (config->ltoPartitions == 0)
     error("--lto-partitions: number of threads must be > 0");
   if (!get_threadpool_strategy(config->thinLTOJobs))
     error("--thinlto-jobs: invalid job count: " + config->thinLTOJobs);
 
   if (config->splitStackAdjustSize < 0)

lld/ELF/ICF.cpp

void ICF<ELFT>::forEachClassRange(size_t begin, size_t end,
   }
 }
 
 // Call Fn on each equivalence class.
 template <class ELFT>
 void ICF<ELFT>::forEachClass(llvm::function_ref<void(size_t, size_t)> fn) {
   // If threading is disabled or the number of sections are
   // too small to use threading, call Fn sequentially.
-  if (!threadsEnabled || sections.size() < 1024) {
+  if (parallel::strategy.ThreadsRequested == 1 || sections.size() < 1024) {
     forEachClassRange(0, sections.size(), fn);
     ++cnt;
     return;
   }
 
   current = cnt % 2;
   next = (cnt + 1) % 2;
 

lld/ELF/Options.td

 def target1_rel: F<"target1-rel">, HelpText<"Interpret R_ARM_TARGET1 as R_ARM_REL32">;
 
 def target1_abs: F<"target1-abs">, HelpText<"Interpret R_ARM_TARGET1 as R_ARM_ABS32 (default)">;
 
 defm target2:
   Eq<"target2", "Interpret R_ARM_TARGET2 as <type>, where <type> is one of rel, abs, or got-rel">,
   MetaVarName<"<type>">;
 
-defm threads: B<"threads",
-    "Run the linker multi-threaded (default)",
-    "Do not run the linker multi-threaded">;
+defm threads
+    : Eq<"threads",
+         "Number of threads. '1' disables multi-threading. By default all "
+         "available hardware threads are used">;
 
 def time_trace: F<"time-trace">, HelpText<"Record time trace">;
 def time_trace_file_eq: J<"time-trace-file=">, HelpText<"Specify time trace output file">;
 
 defm time_trace_granularity: Eq<"time-trace-granularity",
   "Minimum time granularity (in microseconds) traced by time profiler">;
 
 defm toc_optimize : B<"toc-optimize",

 def shuffle_sections: J<"shuffle-sections=">, MetaVarName<"<seed>">,
   HelpText<"Shuffle input sections using the given seed. If 0, use a random seed">;
 def thinlto_cache_dir: J<"thinlto-cache-dir=">,
   HelpText<"Path to ThinLTO cached object file directory">;
 defm thinlto_cache_policy: Eq<"thinlto-cache-policy", "Pruning policy for the ThinLTO cache">;
 def thinlto_emit_imports_files: F<"thinlto-emit-imports-files">;
 def thinlto_index_only: F<"thinlto-index-only">;
 def thinlto_index_only_eq: J<"thinlto-index-only=">;
-def thinlto_jobs: J<"thinlto-jobs=">, HelpText<"Number of ThinLTO jobs">;
+def thinlto_jobs: J<"thinlto-jobs=">,
+  HelpText<"Number of ThinLTO jobs. Default to --threads=">;
 def thinlto_object_suffix_replace_eq: J<"thinlto-object-suffix-replace=">;
 def thinlto_prefix_replace_eq: J<"thinlto-prefix-replace=">;
 
 def: J<"plugin-opt=O">, Alias<lto_O>, HelpText<"Alias for -lto-O">;
 def: F<"plugin-opt=debug-pass-manager">,
   Alias<lto_debug_pass_manager>, HelpText<"Alias for -lto-debug-pass-manager">;
 def: F<"plugin-opt=disable-verify">, Alias<disable_verify>, HelpText<"Alias for -disable-verify">;
 def plugin_opt_dwo_dir_eq: J<"plugin-opt=dwo_dir=">,

lld/ELF/SyntheticSections.cpp

createSymbols(ArrayRef<std::vector<GdbIndexSection::NameAttrEntry>> nameAttrs,
   for (uint32_t i = 0, e = chunks.size(); i != e; ++i) {
     cuIdxs[i] = cuIdx;
     cuIdx += chunks[i].compilationUnits.size();
   }
 
   // The number of symbols we will handle in this function is of the order
   // of millions for very large executables, so we use multi-threading to
   // speed it up.
-  size_t numShards = 32;
-  size_t concurrency = 1;
-  if (threadsEnabled)
-    concurrency = std::min<size_t>(
-        PowerOf2Floor(hardware_concurrency().compute_thread_count()),
-        numShards);
+  constexpr size_t numShards = 32;
+  size_t concurrency = PowerOf2Floor(
+      std::min<size_t>(hardware_concurrency(parallel::strategy.ThreadsRequested)
+                           .compute_thread_count(),
+                       numShards));
 
   // A sharded map to uniquify symbols by name.
   std::vector<DenseMap<CachedHashStringRef, size_t>> map(numShards);
   size_t shift = 32 - countTrailingZeros(numShards);
 
   // Instantiate GdbSymbols while uniqufying them by name.
   std::vector<std::vector<GdbSymbol>> symbols(numShards);
   parallelForEachN(0, concurrency, [&](size_t threadId) {

 // T into different string builders without worrying about merge misses.
 // We do it in parallel.
 void MergeNoTailSection::finalizeContents() {
   // Initializes string table builders.
   for (size_t i = 0; i < numShards; ++i)
     shards.emplace_back(StringTableBuilder::RAW, alignment);
 
   // Concurrency level. Must be a power of 2 to avoid expensive modulo
   // operations in the following tight loop.
-  size_t concurrency = 1;
-  if (threadsEnabled)
-    concurrency = std::min<size_t>(
-        PowerOf2Floor(hardware_concurrency().compute_thread_count()),
-        numShards);
+  size_t concurrency = PowerOf2Floor(
+      std::min<size_t>(hardware_concurrency(parallel::strategy.ThreadsRequested)
+                           .compute_thread_count(),
+                       numShards));
 
   // Add section pieces to the builders.
   parallelForEachN(0, concurrency, [&](size_t threadId) {
     for (MergeInputSection *sec : sections) {
       for (size_t i = 0, e = sec->pieces.size(); i != e; ++i) {
         if (!sec->pieces[i].live)
           continue;
         size_t shardId = getShardId(sec->pieces[i].hash);

lld/docs/ld.lld.1

 .It Fl -no-merge-exidx-entries
 Disable merging .ARM.exidx entries.
 .It Fl -no-nmagic
 Page align sections.
 .It Fl -no-omagic
 Do not set the text data sections to be writable, page align sections.
 .It Fl -no-rosegment
 Do not put read-only non-executable sections in their own segment.
-.It Fl -no-threads
-Do not run the linker multi-threaded.
 .It Fl -no-undefined-version
 Report version scripts that refer undefined symbols.
 .It Fl -no-undefined
 Report unresolved symbols even if the linker is creating a shared library.
 .It Fl -no-warn-symbol-ordering
 Do not warn about problems with the symbol ordering file or call graph profile.
 .It Fl -no-whole-archive
 Restores the default behavior of loading archive members.

 .Li .text
 as the sectionname.
 .It Fl -thinlto-cache-dir Ns = Ns Ar value
 Path to ThinLTO cached object file directory.
 .It Fl -thinlto-cache-policy Ns = Ns Ar value
 Pruning policy for the ThinLTO cache.
 .It Fl -thinlto-jobs Ns = Ns Ar value
 Number of ThinLTO jobs.
-.It Fl -threads
-Run the linker multi-threaded.
-This option is enabled by default.
+.It Fl -threads Ns = Ns Ar N
+Number of threads.
+.Cm all
+(default) means all of concurrent threads supported.
+.Cm 1
+disables multi-threading.
 .It Fl -trace
 Print the names of the input files.
 .It Fl -trace-symbol Ns = Ns Ar symbol , Fl y Ar symbol
 Trace references to
 .Ar symbol .
 .It Fl -undefined Ns = Ns Ar symbol , Fl u Ar symbol
 If
 .Ar symbol

lld/include/lld/Common/Threads.h

 #ifndef LLD_COMMON_THREADS_H
 #define LLD_COMMON_THREADS_H
 
 #include "llvm/Support/Parallel.h"
 #include <functional>
 
 namespace lld {
 
-extern bool threadsEnabled;
-
 template <typename R, class FuncTy> void parallelForEach(R &&range, FuncTy fn) {
-  if (threadsEnabled)
+  if (llvm::parallel::strategy.ThreadsRequested != 1)
     for_each(llvm::parallel::par, std::begin(range), std::end(range), fn);
   else
     for_each(llvm::parallel::seq, std::begin(range), std::end(range), fn);
 }
 
 inline void parallelForEachN(size_t begin, size_t end,
                              llvm::function_ref<void(size_t)> fn) {
-  if (threadsEnabled)
+  if (llvm::parallel::strategy.ThreadsRequested != 1)
     for_each_n(llvm::parallel::par, begin, end, fn);
   else
     for_each_n(llvm::parallel::seq, begin, end, fn);
 }
 
 template <typename R, class FuncTy> void parallelSort(R &&range, FuncTy fn) {
-  if (threadsEnabled)
+  if (llvm::parallel::strategy.ThreadsRequested != 1)
     sort(llvm::parallel::par, std::begin(range), std::end(range), fn);
   else
     sort(llvm::parallel::seq, std::begin(range), std::end(range), fn);
 }
 
 } // namespace lld
 
 #endif

lld/test/COFF/pdb-globals.test

 RUN: yaml2obj %S/Inputs/pdb-globals.yaml > %t.obj
 RUN: lld-link /debug /nodefaultlib /entry:main /out:%t.exe /pdb:%t.pdb %t.obj
 RUN: llvm-pdbutil dump -symbols -globals %t.pdb | FileCheck %s
 
-RUN: lld-link /debug /nodefaultlib /entry:main /out:%t.exe /pdb:%t.pdb %t.obj /threads
+RUN: lld-link /debug /nodefaultlib /entry:main /out:%t.exe /pdb:%t.pdb %t.obj /threads:1
 RUN: llvm-pdbutil dump -symbols -globals %t.pdb | FileCheck %s
-RUN: lld-link /debug /nodefaultlib /entry:main /out:%t.exe /pdb:%t.pdb %t.obj /threads:no
+RUN: lld-link /debug /nodefaultlib /entry:main /out:%t.exe /pdb:%t.pdb %t.obj /threads:2
 RUN: llvm-pdbutil dump -symbols -globals %t.pdb | FileCheck %s
 
 # Test that we correctly distribute symbols between the globals and module
 # symbol streams.  Specifically:
 #  * S_UDT, S_GDATA32, and S_CONSTANT end up in the globals stream, and are
 #    omitted from the module stream.
 #  * S_GPROC32 and S_LPROC32 end up in the symbols stream, but S_PROCREF and
 #    S_LPROCREF are added to the globals stream that refer to the module

lld/test/ELF/build-id.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
 # RUN: ld.lld --build-id %t -o %t2
 # RUN: llvm-readobj -S %t2 | FileCheck -check-prefix=ALIGN %s
 
-# RUN: ld.lld --build-id %t -o %t2 -threads
+# RUN: ld.lld --build-id %t -o %t2
 # RUN: llvm-objdump -s %t2 | FileCheck --check-prefix=DEFAULT %s
-# RUN: ld.lld --build-id=fast %t -o %t2 -threads
+# RUN: ld.lld --build-id=fast %t -o %t2
 # RUN: llvm-objdump -s %t2 | FileCheck --check-prefix=DEFAULT %s
-# RUN: ld.lld --build-id %t -o %t2 -no-threads
+# RUN: ld.lld --build-id %t -o %t2 --threads=1
 # RUN: llvm-objdump -s %t2 | FileCheck --check-prefix=DEFAULT %s
 
-# RUN: ld.lld --build-id=md5 %t -o %t2 -threads
+# RUN: ld.lld --build-id=md5 %t -o %t2
 # RUN: llvm-objdump -s %t2 | FileCheck --check-prefix=MD5 %s
-# RUN: ld.lld --build-id=md5 %t -o %t2 -no-threads
+# RUN: ld.lld --build-id=md5 %t -o %t2 --threads=1
 # RUN: llvm-objdump -s %t2 | FileCheck --check-prefix=MD5 %s
 
-# RUN: ld.lld --build-id=sha1 %t -o %t2 -threads
+# RUN: ld.lld --build-id=sha1 %t -o %t2
 # RUN: llvm-objdump -s %t2 | FileCheck --check-prefix=SHA1 %s
-# RUN: ld.lld --build-id=sha1 %t -o %t2 -no-threads
+# RUN: ld.lld --build-id=sha1 %t -o %t2 --threads=1
 # RUN: llvm-objdump -s %t2 | FileCheck --check-prefix=SHA1 %s
 
-# RUN: ld.lld --build-id=tree %t -o %t2 -threads
+# RUN: ld.lld --build-id=tree %t -o %t2
 # RUN: llvm-objdump -s %t2 | FileCheck --check-prefix=SHA1 %s
-# RUN: ld.lld --build-id=tree %t -o %t2 -no-threads
+# RUN: ld.lld --build-id=tree %t -o %t2 --threads=1
 # RUN: llvm-objdump -s %t2 | FileCheck --check-prefix=SHA1 %s
 
 # RUN: ld.lld --build-id=uuid %t -o %t2
 # RUN: llvm-objdump -s %t2 | FileCheck --check-prefix=UUID %s
 
 # RUN: ld.lld --build-id=0x12345678 %t -o %t2
 # RUN: llvm-objdump -s %t2 | FileCheck --check-prefix=HEX %s
 

lld/test/ELF/lto/thinlto.ll

 ; RUN: llvm-nm %t32.lto.o | FileCheck %s --check-prefix=NM2
 
 ;; --plugin-opt=jobs= is an alias.
 ; RUN: rm -f %t31.lto.o %t32.lto.o
 ; RUN: ld.lld -save-temps --plugin-opt=jobs=2 -shared %t1.o %t2.o -o %t3
 ; RUN: llvm-nm %t31.lto.o | FileCheck %s --check-prefix=NM1
 ; RUN: llvm-nm %t32.lto.o | FileCheck %s --check-prefix=NM2
 
+;; --thinlto-jobs= defaults to --threads=.
+; RUN: rm -f %t31.lto.o %t32.lto.o
+; RUN: ld.lld -save-temps --threads=2 -shared %t1.o %t2.o -o %t3
+; RUN: llvm-nm %t31.lto.o | FileCheck %s --check-prefix=NM1
+; RUN: llvm-nm %t32.lto.o | FileCheck %s --check-prefix=NM2
+
+;; --thinlto-jobs= overrides --threads=.
+; RUN: rm -f %t31.lto.o %t32.lto.o
+; RUN: ld.lld -save-temps --threads=1 --plugin-opt=jobs=2 -shared %t1.o %t2.o -o %t3
+; RUN: llvm-nm %t31.lto.o | FileCheck %s --check-prefix=NM1
+; RUN: llvm-nm %t32.lto.o | FileCheck %s --check-prefix=NM2
+
 ; Test with all threads, on all cores, on all CPU sockets
 ; RUN: rm -f %t31.lto.o %t32.lto.o
 ; RUN: ld.lld -save-temps --thinlto-jobs=all -shared %t1.o %t2.o -o %t3
 ; RUN: llvm-nm %t31.lto.o | FileCheck %s --check-prefix=NM1
 ; RUN: llvm-nm %t32.lto.o | FileCheck %s --check-prefix=NM2
 
 ; Test with many more threads than the system has
 ; RUN: rm -f %t31.lto.o %t32.lto.o

lld/test/ELF/threads.s

+# RUN: llvm-mc -filetype=obj -triple=x86_64 %s -o %t.o
+
+## A positive integer is allowed.
+# RUN: ld.lld --threads=1 %t.o -o /dev/null
+# RUN: ld.lld --threads=2 %t.o -o /dev/null
+
+# RUN: not ld.lld --threads=all %t.o -o /dev/null 2>&1 | FileCheck %s -DN=all
+# RUN: not ld.lld --threads=0 %t.o -o /dev/null 2>&1 | FileCheck %s -DN=0
+# RUN: not ld.lld --threads=-1 %t.o -o /dev/null 2>&1 | FileCheck %s -DN=-1
+
+# CHECK: error: --threads: expected a positive integer, but got '[[N]]'

lld/test/wasm/lto/thinlto.ll

 ; Basic ThinLTO tests.
 ; RUN: opt -module-summary %s -o %t1.o
 ; RUN: opt -module-summary %p/Inputs/thinlto.ll -o %t2.o
 
 ; First force single-threaded mode
 ; RUN: rm -f %t31.lto.o %t32.lto.o
 ; RUN: wasm-ld -r -save-temps --thinlto-jobs=1 %t1.o %t2.o -o %t3
 ; RUN: llvm-nm %t31.lto.o | FileCheck %s --check-prefix=NM1
 ; RUN: llvm-nm %t32.lto.o | FileCheck %s --check-prefix=NM2
 
 ; Next force multi-threaded mode
 ; RUN: rm -f %t31.lto.o %t32.lto.o
 ; RUN: wasm-ld -r -save-temps --thinlto-jobs=2 %t1.o %t2.o -o %t3
 ; RUN: llvm-nm %t31.lto.o | FileCheck %s --check-prefix=NM1
 ; RUN: llvm-nm %t32.lto.o | FileCheck %s --check-prefix=NM2
 
+;; --thinlto-jobs= defaults to --threads=.
+; RUN: rm -f %t31.lto.o %t32.lto.o
+; RUN: wasm-ld -r -save-temps --threads=2 %t1.o %t2.o -o %t3
+; RUN: llvm-nm %t31.lto.o | FileCheck %s --check-prefix=NM1
+; RUN: llvm-nm %t32.lto.o | FileCheck %s --check-prefix=NM2
+
+;; --thinlto-jobs= overrides --threads=.
+; RUN: rm -f %t31.lto.o %t32.lto.o
+; RUN: wasm-ld -r -save-temps --threads=1 --thinlto-jobs=2 %t1.o %t2.o -o %t3
+; RUN: llvm-nm %t31.lto.o | FileCheck %s --check-prefix=NM1
+; RUN: llvm-nm %t32.lto.o | FileCheck %s --check-prefix=NM2
+
 ; Test with all threads, on all cores, on all CPU sockets
 ; RUN: rm -f %t31.lto.o %t32.lto.o
 ; RUN: wasm-ld -r -save-temps --thinlto-jobs=all %t1.o %t2.o -o %t3
 ; RUN: llvm-nm %t31.lto.o | FileCheck %s --check-prefix=NM1
 ; RUN: llvm-nm %t32.lto.o | FileCheck %s --check-prefix=NM2
 
 ; Test with many more threads than the system has
 ; RUN: rm -f %t31.lto.o %t32.lto.o

lld/test/wasm/threads.s

+# RUN: llvm-mc -filetype=obj -triple=wasm32 %s -o %t.o
+
+## A positive integer is allowed.
+# RUN: wasm-ld --no-entry %t.o -o /dev/null
+# RUN: wasm-ld --no-entry --threads=1 %t.o -o /dev/null
+# RUN: wasm-ld --no-entry --threads=2 %t.o -o /dev/null
+
+# RUN: not wasm-ld --threads=all %t.o -o /dev/null 2>&1 | FileCheck %s -DN=all
+# RUN: not wasm-ld --threads=0 %t.o -o /dev/null 2>&1 | FileCheck %s -DN=0
+# RUN: not wasm-ld --threads=-1 %t.o -o /dev/null 2>&1 | FileCheck %s -DN=-1
+
+# CHECK: error: --threads: expected a positive integer, but got '[[N]]'

lld/wasm/Driver.cpp

static void readConfigs(opt::InputArgList &args) {
   config->stripAll = args.hasArg(OPT_strip_all);
   config->stripDebug = args.hasArg(OPT_strip_debug);
   config->stackFirst = args.hasArg(OPT_stack_first);
   config->trace = args.hasArg(OPT_trace);
   config->thinLTOCacheDir = args.getLastArgValue(OPT_thinlto_cache_dir);
   config->thinLTOCachePolicy = CHECK(
       parseCachePruningPolicy(args.getLastArgValue(OPT_thinlto_cache_policy)),
       "--thinlto-cache-policy: invalid cache policy");
-  config->thinLTOJobs = args.getLastArgValue(OPT_thinlto_jobs);
   errorHandler().verbose = args.hasArg(OPT_verbose);
   LLVM_DEBUG(errorHandler().verbose = true);
-  threadsEnabled = args.hasFlag(OPT_threads, OPT_no_threads, true);
 
   config->initialMemory = args::getInteger(args, OPT_initial_memory, 0);
   config->globalBase = args::getInteger(args, OPT_global_base, 1024);
   config->maxMemory = args::getInteger(args, OPT_max_memory, 0);
   config->zStackSize =
       args::getZOptionValue(args, OPT_z, "stack-size", WasmPageSize);
 
   // Default value of exportDynamic depends on `-shared`
   config->exportDynamic =
       args.hasFlag(OPT_export_dynamic, OPT_no_export_dynamic, config->shared);
 
+  // --threads= takes a positive integer and provides the default value for
+  // --thinlto-jobs=.
+  if (auto *arg = args.getLastArg(OPT_threads)) {
+    StringRef v(arg->getValue());
+    unsigned threads = 0;
+    if (!llvm::to_integer(v, threads, 0) || threads == 0)
+      error(arg->getSpelling() + ": expected a positive integer, but got '" +
+            arg->getValue() + "'");
+    parallel::strategy = hardware_concurrency(threads);
+    config->thinLTOJobs = v;
+  }
+  if (auto *arg = args.getLastArg(OPT_thinlto_jobs))
+    config->thinLTOJobs = arg->getValue();
+
   if (auto *arg = args.getLastArg(OPT_features)) {
     config->features =
         llvm::Optional<std::vector<std::string>>(std::vector<std::string>());
     for (StringRef s : arg->getValues())
       config->features->push_back(std::string(s));
   }
 }
 

lld/wasm/Options.td

 def l: JoinedOrSeparate<["-"], "l">, MetaVarName<"<libName>">,
   HelpText<"Root name of library to use">;
 
 def L: JoinedOrSeparate<["-"], "L">, MetaVarName<"<dir>">,
   HelpText<"Add a directory to the library search path">;
 
 def mllvm: S<"mllvm">, HelpText<"Options to pass to LLVM">;
 
-def no_threads: F<"no-threads">,
-  HelpText<"Do not run the linker multi-threaded">;
-
 def no_color_diagnostics: F<"no-color-diagnostics">,
   HelpText<"Do not use colors in diagnostics">;
 
 def no_fatal_warnings: F<"no-fatal-warnings">;
 
 def o: JoinedOrSeparate<["-"], "o">, MetaVarName<"<path>">,
   HelpText<"Path to file to write output">;
 
defm rsp_quoting: Eq<"rsp-quoting", "Quoting style for response files">,
   MetaVarName<"[posix,windows]">;
 
 def shared: F<"shared">, HelpText<"Build a shared object">;
 
 def strip_all: F<"strip-all">, HelpText<"Strip all symbols">;
 
 def strip_debug: F<"strip-debug">, HelpText<"Strip debugging information">;
 
-def threads: F<"threads">, HelpText<"Run the linker multi-threaded">;
+defm threads
+    : Eq<"threads", "Number of threads. '1' disables multi-threading. By "
+                    "default all available hardware threads are used">;
 
 def trace: F<"trace">, HelpText<"Print the names of the input files">;
 
 defm trace_symbol: Eq<"trace-symbol", "Trace references to symbols">;
 
 defm undefined: Eq<"undefined", "Force undefined symbol during linking">;
 
 def v: Flag<["-"], "v">, HelpText<"Display the version number">;
def lto_O: J<"lto-O">, MetaVarName<"<opt-level>">,
   HelpText<"Optimization level for LTO">;
 def lto_partitions: J<"lto-partitions=">,
   HelpText<"Number of LTO codegen partitions">;
 def disable_verify: F<"disable-verify">;
 def save_temps: F<"save-temps">;
 def thinlto_cache_dir: J<"thinlto-cache-dir=">,
   HelpText<"Path to ThinLTO cached object file directory">;
 defm thinlto_cache_policy: Eq<"thinlto-cache-policy", "Pruning policy for the ThinLTO cache">;
-def thinlto_jobs: J<"thinlto-jobs=">, HelpText<"Number of ThinLTO jobs">;
+def thinlto_jobs: J<"thinlto-jobs=">,
+  HelpText<"Number of ThinLTO jobs. Default to --threads=">;

llvm/include/llvm/Support/Parallel.h

 //===- llvm/Support/Parallel.h - Parallel algorithms ----------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_PARALLEL_H
 #define LLVM_SUPPORT_PARALLEL_H
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/Support/MathExtras.h"
+#include "llvm/Support/Threading.h"
 
 #include <algorithm>
 #include <condition_variable>
 #include <functional>
 #include <mutex>
 
 namespace llvm {
 
 namespace parallel {
 struct sequential_execution_policy {};
 struct parallel_execution_policy {};
 
 template <typename T>
 struct is_execution_policy
     : public std::integral_constant<
           bool, llvm::is_one_of<T, sequential_execution_policy,
                                 parallel_execution_policy>::value> {};
 
 constexpr sequential_execution_policy seq{};
 constexpr parallel_execution_policy par{};
 
+// Strategy for the default executor used by the parallel routines provided by
+// this file. It defaults to using all hardware threads and should be
+// initialized before the first use of parallel routines.
+extern ThreadPoolStrategy strategy;
+
 namespace detail {
 
 #if LLVM_ENABLE_THREADS
 
 class Latch {
   uint32_t Count;
   mutable std::mutex Mutex;
   mutable std::condition_variable Cond;

llvm/lib/Support/Parallel.cpp

 #include "llvm/Support/Threading.h"
 
 #include <atomic>
 #include <future>
 #include <stack>
 #include <thread>
 #include <vector>
 
+llvm::ThreadPoolStrategy llvm::parallel::strategy;
+
 namespace llvm {
 namespace parallel {
 namespace detail {
 
 namespace {
 
 /// An abstract class that takes closures and runs them asynchronously.
 class Executor {
~ThreadPoolExecutor() override {
     std::thread::id CurrentThreadId = std::this_thread::get_id();
     for (std::thread &T : Threads)
       if (T.get_id() == CurrentThreadId)
         T.detach();
       else
         T.join();
   }
 
+  struct Creator {
+    static void *call() { return new ThreadPoolExecutor(strategy); }
+  };
   struct Deleter {
     static void call(void *Ptr) { ((ThreadPoolExecutor *)Ptr)->stop(); }
   };
 
   void add(std::function<void()> F) override {
     {
       std::lock_guard<std::mutex> Lock(Mutex);
       WorkStack.push(F);
Executor *Executor::getDefaultExecutor() {
   // destructor ensures it has been stopped and waits for worker threads to
   // finish. The wait is important as it prevents intermittent crashes on
   // Windows when the process is doing a full exit.
   //
   // The Windows crashes appear to only occur with the MSVC static runtimes and
   // are more frequent with the debug static runtime.
   //
   // This also prevents intermittent deadlocks on exit with the MinGW runtime.
-  static ManagedStatic<ThreadPoolExecutor, object_creator<ThreadPoolExecutor>,
+
+  static ManagedStatic<ThreadPoolExecutor, ThreadPoolExecutor::Creator,
                        ThreadPoolExecutor::Deleter>
       ManagedExec;
   static std::unique_ptr<ThreadPoolExecutor> Exec(&(*ManagedExec));
   return Exec.get();
 }
 } // namespace
 
 static std::atomic<int> TaskGroupInstances;
 
 // Latch::sync() called by the dtor may cause one thread to block. If is a dead

llvm/utils/gn/secondary/lld/Common/BUILD.gn

sources = [
     "Args.cpp",
     "DWARF.cpp",
     "ErrorHandler.cpp",
     "Filesystem.cpp",
     "Memory.cpp",
     "Reproduce.cpp",
     "Strings.cpp",
     "TargetOptionsCommandFlags.cpp",
-    "Threads.cpp",
     "Timer.cpp",
     "Version.cpp",
   ]
   defines = [ "HAVE_VCS_VERSION_INC" ]  # For Version.cpp
 }