tree 5063236cd618f5f80b1bc98ad4ea8e43571f25dd
parent d69a9c3765dee2e650bcccebbadf72c5d42d92b1
author Tom Anderson <thomasanderson@chromium.org> 1550194292 -0800
committer Commit Bot <commit-bot@chromium.org> 1550252789 +0000

Pass -lpthread when linking instead of -pthread

-pthread is meant to be passed when compiling, not linking.
Prevents build errors on clang 9 like the following:

    clang++ -fuse-ld=lld -nodefaultlibs libc++.so -lc -lm -Wl,-rpath="\$ORIGIN/." -Wl,-rpath-link=. -O3 -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,-strip-all -static-libstdc++ -Wl,--as-needed -pthread -o gn -Wl,--start-group tools/gn/gn_main.o base.a gn_lib.a -Wl,--end-group -ldl
     clang-9: warning: argument unused during compilation: '-pthread' [-Wunused-command-line-argument]
     ld.lld: error: undefined symbol: pthread_create
     >>> referenced by worker_pool.cc
     >>>               util/worker_pool.o:(WorkerPool::WorkerPool(unsigned long)) in archive gn_lib.a

Verified the build works on earlier versions of clang and gcc.

BUG=chromium:932041,chromium:807400
R=brettw

Change-Id: I1b876ae43a5b9b04f82828680612641e49f86de2
Reviewed-on: https://gn-review.googlesource.com/c/4000
Reviewed-by: Brett Wilson <brettw@chromium.org>
Commit-Queue: Brett Wilson <brettw@chromium.org>
