link libssp via TBB_COMMON_LINK_LIBS rather than the shared linker flags

TBB compiles with -fstack-protector-strong and _FORTIFY_SOURCE=2, and on
mingw the helpers those need (__stack_chk_fail, __stack_chk_guard,
__strncpy_chk, ...) live in libssp rather than libgcc. Rtools42 (gcc 10)
does not pull it in implicitly, so the link fails with undefined
references to them.

Passing -lssp through CMAKE_SHARED_LINKER_FLAGS was not enough: those
flags are emitted before the objects, and GNU ld only resolves symbols
that are already undefined when it reaches a library, so it was
discarded. tbb and tbbmalloc happened to survive that because
tbb_handle_ipo gives them LTO; tbbmalloc_proxy has no such call and
failed to link. Putting ssp in TBB_COMMON_LINK_LIBS routes it through
target_link_libraries instead, which lands after the objects, and covers
all three targets.

Author: kevinushey

patches/mingw_clang_cmake.diff

@@ -1,6 +1,6 @@
 --- a/src/tbb/cmake/compilers/Clang.cmake
 +++ b/src/tbb/cmake/compilers/Clang.cmake
-@@ -65,8 +65,12 @@ endif()
+@@ -65,13 +65,27 @@
  # Clang flags to prevent compiler from optimizing out security checks
  set(TBB_COMMON_COMPILE_FLAGS ${TBB_COMMON_COMPILE_FLAGS} -Wformat -Wformat-security -Werror=format-security -fPIC $<$<NOT:$<BOOL:${EMSCRIPTEN}>>:-fstack-protector-strong>)
 
@@ -15,3 +15,18 @@
      set(TBB_LIB_LINK_FLAGS ${TBB_LIB_LINK_FLAGS} -Wl,-z,relro,-z,now)
  endif()
 
+ set(TBB_COMMON_LINK_LIBS ${CMAKE_DL_LIBS})
+ 
++# Local addition: on mingw the helpers for -fstack-protector-strong and
++# _FORTIFY_SOURCE (__stack_chk_fail, __stack_chk_guard, __strncpy_chk, ...)
++# live in libssp rather than libgcc, and older toolchains (Rtools42 / gcc 10)
++# do not pull it in implicitly. It has to go here, with the link libraries,
++# rather than in the linker flags: those are emitted before the objects, and
++# GNU ld only resolves symbols already undefined when it reaches a library.
++if (MINGW)
++    set(TBB_COMMON_LINK_LIBS ${TBB_COMMON_LINK_LIBS} ssp)
++endif()
++
+ if (NOT CMAKE_CXX_FLAGS MATCHES "_FORTIFY_SOURCE")
+   set(TBB_COMMON_COMPILE_FLAGS ${TBB_COMMON_COMPILE_FLAGS} $<$<NOT:$<CONFIG:Debug>>:-D_FORTIFY_SOURCE=2>)
+ endif ()

patches/mingw_gnu_cmake.diff

@@ -1,8 +1,6 @@
-diff --git a/src/tbb/cmake/compilers/GNU.cmake b/src/tbb/cmake/compilers/GNU.cmake
-index cf6d8bdb..8f9f0b59 100644
 --- a/src/tbb/cmake/compilers/GNU.cmake
 +++ b/src/tbb/cmake/compilers/GNU.cmake
-@@ -47,19 +47,44 @@ endif()
+@@ -47,19 +47,44 @@
  # >=2.31.1). Capturing the output in CMake can be done like below. The version
  # information is written to either stdout or stderr. To not make any
  # assumptions, both are captured.
@@ -48,19 +46,37 @@ index cf6d8bdb..8f9f0b59 100644
  message(TRACE "Extracted GNU assembler version: major=${_tbb_gnu_asm_major_version} minor=${_tbb_gnu_asm_minor_version}")
 
  math(EXPR _tbb_gnu_asm_version_number  "${_tbb_gnu_asm_major_version} * 1000 + ${_tbb_gnu_asm_minor_version}")
-@@ -81,7 +106,14 @@ endif()
+@@ -73,6 +98,16 @@
+ 
+ set(TBB_COMMON_LINK_LIBS ${CMAKE_DL_LIBS})
+ 
++# Local addition: on mingw the helpers for -fstack-protector-strong and
++# _FORTIFY_SOURCE (__stack_chk_fail, __stack_chk_guard, __strncpy_chk, ...)
++# live in libssp rather than libgcc, and older toolchains (Rtools42 / gcc 10)
++# do not pull it in implicitly. It has to go here, with the link libraries,
++# rather than in the linker flags: those are emitted before the objects, and
++# GNU ld only resolves symbols already undefined when it reaches a library.
++if (MINGW)
++    set(TBB_COMMON_LINK_LIBS ${TBB_COMMON_LINK_LIBS} ssp)
++endif()
++
+ # Ignore -Werror set through add_compile_options() or added to CMAKE_CXX_FLAGS if TBB_STRICT is disabled.
+ if (NOT TBB_STRICT AND COMMAND tbb_remove_compile_flag)
+     tbb_remove_compile_flag(-Werror)
+@@ -81,8 +116,15 @@
  if (NOT ${CMAKE_CXX_COMPILER_ID} STREQUAL Intel)
      # gcc 6.0 and later have -flifetime-dse option that controls elimination of stores done outside the object lifetime
      set(TBB_DSE_FLAG $<$<NOT:$<VERSION_LESS:${CMAKE_CXX_COMPILER_VERSION},6.0>>:-flifetime-dse=1>)
 -    set(TBB_COMMON_COMPILE_FLAGS ${TBB_COMMON_COMPILE_FLAGS} $<$<NOT:$<VERSION_LESS:${CMAKE_CXX_COMPILER_VERSION},8.0>>:-fstack-clash-protection>)
-+
+ 
 +    # -fstack-clash-protection is broken on mingw's SEH targets: compiling
 +    # task_dispatcher.h makes GCC 10 abort with "internal compiler error: in
 +    # seh_emit_stackalloc, at config/i386/winnt.c". It is a hardening flag
 +    # rather than a correctness one, so simply leave it off there.
 +    if (NOT MINGW)
 +        set(TBB_COMMON_COMPILE_FLAGS ${TBB_COMMON_COMPILE_FLAGS} $<$<NOT:$<VERSION_LESS:${CMAKE_CXX_COMPILER_VERSION},8.0>>:-fstack-clash-protection>)
 +    endif()
- 
++
      # Suppress GCC 12.x-13.x warning here that to_wait_node(n)->my_is_in_list might have size 0
      set(TBB_COMMON_LINK_FLAGS ${TBB_COMMON_LINK_FLAGS} $<$<AND:$<NOT:$<VERSION_LESS:${CMAKE_CXX_COMPILER_VERSION},12.0>>,$<VERSION_LESS:${CMAKE_CXX_COMPILER_VERSION},14.0>>:-Wno-stringop-overflow>)
+ endif()

src/install.libs.R

@@ -315,12 +315,6 @@ useBundledTbb <- function() {
    if (.Platform$OS.type == "windows") {
       cmakeFlags <- c(
          "-G", "MSYS Makefiles",
-         # TBB compiles with -fstack-protector-strong and _FORTIFY_SOURCE, and
-         # on mingw the helpers those need (__stack_chk_fail, __strncpy_chk and
-         # friends) live in libssp rather than in libgcc. Newer toolchains pull
-         # it in implicitly; Rtools42 (gcc 10) does not, and the TBB link then
-         # fails with undefined references to them
-         "-DCMAKE_SHARED_LINKER_FLAGS=-lssp",
          cmakeFlags
       )
    }

src/tbb/cmake/compilers/Clang.cmake

@@ -76,6 +76,16 @@ endif()
 
 set(TBB_COMMON_LINK_LIBS ${CMAKE_DL_LIBS})
 
+# Local addition: on mingw the helpers for -fstack-protector-strong and
+# _FORTIFY_SOURCE (__stack_chk_fail, __stack_chk_guard, __strncpy_chk, ...)
+# live in libssp rather than libgcc, and older toolchains (Rtools42 / gcc 10)
+# do not pull it in implicitly. It has to go here, with the link libraries,
+# rather than in the linker flags: those are emitted before the objects, and
+# GNU ld only resolves symbols already undefined when it reaches a library.
+if (MINGW)
+    set(TBB_COMMON_LINK_LIBS ${TBB_COMMON_LINK_LIBS} ssp)
+endif()
+
 if (NOT CMAKE_CXX_FLAGS MATCHES "_FORTIFY_SOURCE")
   set(TBB_COMMON_COMPILE_FLAGS ${TBB_COMMON_COMPILE_FLAGS} $<$<NOT:$<CONFIG:Debug>>:-D_FORTIFY_SOURCE=2>)
 endif ()

src/tbb/cmake/compilers/GNU.cmake

@@ -98,6 +98,16 @@ endif()
 
 set(TBB_COMMON_LINK_LIBS ${CMAKE_DL_LIBS})
 
+# Local addition: on mingw the helpers for -fstack-protector-strong and
+# _FORTIFY_SOURCE (__stack_chk_fail, __stack_chk_guard, __strncpy_chk, ...)
+# live in libssp rather than libgcc, and older toolchains (Rtools42 / gcc 10)
+# do not pull it in implicitly. It has to go here, with the link libraries,
+# rather than in the linker flags: those are emitted before the objects, and
+# GNU ld only resolves symbols already undefined when it reaches a library.
+if (MINGW)
+    set(TBB_COMMON_LINK_LIBS ${TBB_COMMON_LINK_LIBS} ssp)
+endif()
+
 # Ignore -Werror set through add_compile_options() or added to CMAKE_CXX_FLAGS if TBB_STRICT is disabled.
 if (NOT TBB_STRICT AND COMMAND tbb_remove_compile_flag)
     tbb_remove_compile_flag(-Werror)