Update deps/libvalkey to version 0.3.0

Squashed 'deps/libvalkey/' changes from b012f8e85..62e757d17

62e757d17 Release 0.3.0 (valkey-io#283)
a554f0942 Fix potential uint32_t underflow issue (valkey-io#280)
8f9051ae0 Correcting command parser bug (valkey-io#277)
29023eb36 Add valkey-json, valkey-bloom, valkey-search to cmddef.h
ae756bc89 Update cmddef.h to Valkey 9.0.0
21abd737e Replace problematic alloca() with fixed stack alloc
38191079c Fix compilation on Solaris with Sun/Solaris Studio
ef5de0312 Make libvalkey initialization thread-safe
ae341dea5 Support slotmap updates using CLUSTER NODES in RESP3 (valkey-io#262)
36f6e2292 Fix the long-blocking read for Valkey RDMA. (valkey-io#233)
c090c28be Use a uintptr_t hop for casting pointers to ints
daa7f11ac Avoid heap buffer overflow in valkeyAsyncFormattedCommand (valkey-io#245)
15974930d Add option to select a logical database (valkey-io#244)
983d67e4f Install the macosx adapter on Apple platforms only
...

git-subtree-dir: deps/libvalkey
git-subtree-split: 62e757d174748642ddd0cefad1ebae3941a6bb92

Signed-off-by: Björn Svensson <bjorn.a.svensson@est.tech>

Author: bjosv

deps/libvalkey/CMakeLists.txt

@@ -11,11 +11,12 @@ getDefinedVersion(VERSION_MAJOR)
 getDefinedVersion(VERSION_MINOR)
 getDefinedVersion(VERSION_PATCH)
 set(VERSION "${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}")
-MESSAGE("Detected version: ${VERSION}")
+message("Detected libvalkey version: ${VERSION}")
 
-PROJECT(valkey LANGUAGES "C" VERSION "${VERSION}")
+project(libvalkey LANGUAGES "C" VERSION "${VERSION}")
 INCLUDE(GNUInstallDirs)
 
+option(ENABLE_THREADS "Enable thread-safe initialization" ON)
 OPTION(BUILD_SHARED_LIBS "Build shared libraries" ON)
 OPTION(ENABLE_TLS "Build valkey_tls for TLS support" OFF)
 OPTION(DISABLE_TESTS "If tests should be compiled or not" OFF)
@@ -70,18 +71,36 @@ set_target_properties(valkey PROPERTIES
   SOVERSION "${VERSION_MAJOR}"
   VERSION "${VERSION}")
 
-IF(MSVC)
-    SET_TARGET_PROPERTIES(valkey
-        PROPERTIES COMPILE_FLAGS /Z7)
-ENDIF()
+if(MSVC)
+  # Produce object files that contain debug info.
+  target_compile_options(valkey PRIVATE /Z7)
+endif()
+
+set(valkey_link_libraries)
+set(valkey_compile_definitions)
+
 IF(WIN32)
-    TARGET_LINK_LIBRARIES(valkey PUBLIC ws2_32 crypt32)
+    list(APPEND valkey_link_libraries ws2_32 crypt32)
 ELSEIF(CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
-    TARGET_LINK_LIBRARIES(valkey PUBLIC m)
+    list(APPEND valkey_link_libraries m)
 ELSEIF(CMAKE_SYSTEM_NAME MATCHES "SunOS")
-    TARGET_LINK_LIBRARIES(valkey PUBLIC socket)
+    list(APPEND valkey_link_libraries socket)
 ENDIF()
 
+if(ENABLE_THREADS)
+    find_package(Threads REQUIRED)
+    list(APPEND valkey_link_libraries Threads::Threads)
+    list(APPEND valkey_compile_definitions VALKEY_USE_THREADS)
+endif()
+
+if(valkey_link_libraries)
+    target_link_libraries(valkey PUBLIC ${valkey_link_libraries})
+endif()
+
+if(valkey_compile_definitions)
+    target_compile_definitions(valkey PRIVATE ${valkey_compile_definitions})
+endif()
+
 TARGET_INCLUDE_DIRECTORIES(valkey
     PUBLIC
         $<INSTALL_INTERFACE:include>
@@ -94,8 +113,9 @@ TARGET_INCLUDE_DIRECTORIES(valkey
 CONFIGURE_FILE(valkey.pc.in valkey.pc @ONLY)
 
 set(CPACK_PACKAGE_VENDOR "Valkey")
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Minimalistic C client library for Valkey")
 set(CPACK_PACKAGE_DESCRIPTION "\
-Libvalkey is a minimalistic C client library for the Valkey, KeyDB, and Redis databases
+Libvalkey is a minimalistic C client library for the Valkey, KeyDB, and Redis databases.
 
 It is minimalistic because it just adds minimal support for the protocol, \
 but at the same time it uses a high level printf-alike API in order to make \
@@ -107,7 +127,7 @@ reply parser that is decoupled from the I/O layer. It is a stream parser designe
 for easy reusability, which can for instance be used in higher level language bindings \
 for efficient reply parsing.
 
-valkey only supports the binary-safe RESP protocol, so you can use it with any Redis \
+Libvalkey only supports the binary-safe RESP protocol, so you can use it with any Redis \
 compatible server >= 1.2.0.
 
 The library comes with multiple APIs. There is the synchronous API, the asynchronous API \
@@ -116,7 +136,9 @@ set(CPACK_PACKAGE_HOMEPAGE_URL "https://github.com/valkey-io/libvalkey")
 set(CPACK_PACKAGE_CONTACT "michael dot grunder at gmail dot com")
 set(CPACK_DEBIAN_PACKAGE_SHLIBDEPS ON)
 set(CPACK_RPM_PACKAGE_AUTOREQPROV ON)
-
+set(CPACK_RPM_PACKAGE_DESCRIPTION "${CPACK_PACKAGE_DESCRIPTION}")
+set(CPACK_RPM_PACKAGE_GROUP "Productivity/Databases/Clients")
+set(CPACK_RPM_PACKAGE_LICENSE "BSD-3-Clause")
 include(CPack)
 
 INSTALL(TARGETS valkey
@@ -125,17 +147,23 @@ INSTALL(TARGETS valkey
     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
     ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
 
-if (MSVC AND BUILD_SHARED_LIBS)
-    INSTALL(FILES $<TARGET_PDB_FILE:valkey>
-        DESTINATION ${CMAKE_INSTALL_BINDIR}
-        CONFIGURATIONS Debug RelWithDebInfo)
+if(MSVC AND BUILD_SHARED_LIBS)
+  # Install linker generated program database file.
+  install(FILES $<TARGET_PDB_FILE:valkey>
+          DESTINATION ${CMAKE_INSTALL_BINDIR}
+          CONFIGURATIONS Debug RelWithDebInfo)
 endif()
 
 # Install public headers
 install(DIRECTORY include/valkey
         DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
         PATTERN "tls.h" EXCLUDE
-        PATTERN "rdma.h" EXCLUDE)
+        PATTERN "rdma.h" EXCLUDE
+        PATTERN "adapters/macosx.h" EXCLUDE)
+if(APPLE)
+  install(FILES include/valkey/adapters/macosx.h
+          DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/valkey/adapters)
+endif()
 
 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/valkey.pc
     DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
@@ -187,23 +215,16 @@ IF(ENABLE_TLS)
             $<BUILD_INTERFACE:${SDS_INCLUDE_DIR}>
     )
 
-    IF (APPLE AND BUILD_SHARED_LIBS)
-        SET_PROPERTY(TARGET valkey_tls PROPERTY LINK_FLAGS "-Wl,-undefined -Wl,dynamic_lookup")
-    ENDIF()
-
     set_target_properties(valkey_tls PROPERTIES
       C_VISIBILITY_PRESET hidden
       WINDOWS_EXPORT_ALL_SYMBOLS TRUE
       SOVERSION "${VERSION_MAJOR}"
       VERSION "${VERSION}")
-    IF(MSVC)
-        SET_TARGET_PROPERTIES(valkey_tls
-            PROPERTIES COMPILE_FLAGS /Z7)
-    ENDIF()
-    TARGET_LINK_LIBRARIES(valkey_tls PRIVATE OpenSSL::SSL)
-    if(WIN32 OR CYGWIN)
-        target_link_libraries(valkey_tls PRIVATE valkey)
+    if(MSVC)
+      # Produce object files that contain debug info.
+      target_compile_options(valkey_tls PRIVATE /Z7)
     endif()
+    target_link_libraries(valkey_tls PRIVATE valkey::valkey OpenSSL::SSL)
     CONFIGURE_FILE(valkey_tls.pc.in valkey_tls.pc @ONLY)
 
     INSTALL(TARGETS valkey_tls
@@ -216,10 +237,11 @@ IF(ENABLE_TLS)
     install(FILES include/valkey/tls.h
             DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/valkey)
 
-    if (MSVC AND BUILD_SHARED_LIBS)
-        INSTALL(FILES $<TARGET_PDB_FILE:valkey_tls>
-            DESTINATION ${CMAKE_INSTALL_BINDIR}
-            CONFIGURATIONS Debug RelWithDebInfo)
+    if(MSVC AND BUILD_SHARED_LIBS)
+      # Install linker generated program database file.
+      install(FILES $<TARGET_PDB_FILE:valkey_tls>
+              DESTINATION ${CMAKE_INSTALL_BINDIR}
+              CONFIGURATIONS Debug RelWithDebInfo)
     endif()
 
     INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/valkey_tls.pc
@@ -254,7 +276,7 @@ if(ENABLE_RDMA)
     add_library(valkey_rdma ${valkey_rdma_sources})
     add_library(valkey::valkey_rdma ALIAS valkey_rdma)
 
-    target_link_libraries(valkey_rdma LINK_PRIVATE ${RDMACM_LIBRARIES} ${IBVERBS_LIBRARIES})
+    target_link_libraries(valkey_rdma PRIVATE valkey::valkey ${RDMACM_LIBRARIES} ${IBVERBS_LIBRARIES})
     target_include_directories(valkey_rdma
         PRIVATE
             $<INSTALL_INTERFACE:include>
@@ -303,26 +325,32 @@ endif()
 
 # Add tests
 if(NOT DISABLE_TESTS)
-  if(BUILD_SHARED_LIBS)
-    # Test using a static library since symbols are not hidden then.
-    # Use same source, include dirs and dependencies as the shared library.
-    add_library(valkey_unittest STATIC ${valkey_sources})
-    get_target_property(include_directories valkey::valkey INCLUDE_DIRECTORIES)
-    target_include_directories(valkey_unittest PUBLIC ${include_directories})
-    get_target_property(link_libraries valkey::valkey LINK_LIBRARIES)
-    if(link_libraries)
-      target_link_libraries(valkey_unittest PUBLIC ${link_libraries})
-    endif()
-    # Create libvalkey_unittest.a in the tests directory.
-    set_target_properties(valkey_unittest PROPERTIES
-      ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/tests")
-  else()
-    # Target is an alias for the static library.
-    add_library(valkey_unittest ALIAS valkey)
+  # Unit tests uses a static library to ensure all symbols are visible.
+  # This single library also bundles TLS and RDMA when enabled.
+  add_library(valkey_unittest STATIC ${valkey_sources} ${valkey_tls_sources} ${valkey_rdma_sources})
+
+  # Mirror the include directories.
+  get_target_property(include_directories valkey::valkey INCLUDE_DIRECTORIES)
+  target_include_directories(valkey_unittest PUBLIC ${include_directories})
+
+  if(valkey_compile_definitions)
+    target_compile_definitions(valkey_unittest PRIVATE ${valkey_compile_definitions})
+  endif()
+  if(valkey_link_libraries)
+    target_link_libraries(valkey_unittest PUBLIC ${valkey_link_libraries})
+  endif()
+  if(ENABLE_TLS)
+    target_link_libraries(valkey_unittest PRIVATE OpenSSL::SSL)
   endif()
+  if(ENABLE_RDMA)
+    target_link_libraries(valkey_unittest PRIVATE ${RDMACM_LIBRARIES} ${IBVERBS_LIBRARIES})
+  endif()
+
+  # Create libvalkey_unittest.a in the tests directory.
+  set_target_properties(valkey_unittest PROPERTIES
+                        ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/tests")
 
   # Make sure ctest prints the output when a test fails.
-  # Must be set before including CTest.
   set(CMAKE_CTEST_ARGUMENTS "--output-on-failure")
   include(CTest)
   add_subdirectory(tests)

deps/libvalkey/CONTRIBUTING.md

@@ -69,7 +69,7 @@ Adhere to the existing coding style and make sure to mimic best possible.
 ### Code formatting
 
 When making a change, please use `git clang-format` or [format-files.sh](./scripts/format-files.sh) to format your changes properly.
-This repository is currently using `clang-format` 18.1.3 to format the code, which can be installed using `pip install clang-format==18.1.3` or other preferred method.
+This repository is currently using `clang-format` 18.1.8 to format the code, which can be installed using `pip install clang-format==18.1.8` or other preferred method.
 
 ## Running cluster tests
 

deps/libvalkey/Makefile

@@ -86,7 +86,7 @@ DYLIB_MAJOR_NAME=$(LIBNAME).$(DYLIBSUFFIX).$(LIBVALKEY_MAJOR)
 DYLIB_ROOT_NAME=$(LIBNAME).$(DYLIBSUFFIX)
 DYLIBNAME=$(LIB_DIR)/$(DYLIB_ROOT_NAME)
 
-DYLIB_MAKE_CMD=$(CC) $(OPTIMIZATION) $(PLATFORM_FLAGS) -shared -Wl,-soname,$(DYLIB_MAJOR_NAME)
+DYLIB_MAKE_CMD=$(CC) $(PLATFORM_FLAGS) -shared -Wl,-soname,$(DYLIB_MAJOR_NAME)
 STLIBNAME=$(LIB_DIR)/$(LIBNAME).$(STLIBSUFFIX)
 STLIB_MAKE_CMD=$(AR) rcs
 
@@ -99,7 +99,7 @@ TLS_DYLIB_MAJOR_NAME=$(TLS_LIBNAME).$(DYLIBSUFFIX).$(LIBVALKEY_MAJOR)
 TLS_DYLIB_ROOT_NAME=$(TLS_LIBNAME).$(DYLIBSUFFIX)
 TLS_DYLIBNAME=$(LIB_DIR)/$(TLS_LIBNAME).$(DYLIBSUFFIX)
 TLS_STLIBNAME=$(LIB_DIR)/$(TLS_LIBNAME).$(STLIBSUFFIX)
-TLS_DYLIB_MAKE_CMD=$(CC) $(OPTIMIZATION) $(PLATFORM_FLAGS) -shared -Wl,-soname,$(TLS_DYLIB_MAJOR_NAME)
+TLS_DYLIB_MAKE_CMD=$(CC) $(PLATFORM_FLAGS) -shared -Wl,-soname,$(TLS_DYLIB_MAJOR_NAME)
 
 USE_TLS?=0
 
@@ -130,7 +130,7 @@ RDMA_DYLIB_MAJOR_NAME=$(RDMA_LIBNAME).$(DYLIBSUFFIX).$(LIBVALKEY_MAJOR)
 RDMA_DYLIB_ROOT_NAME=$(RDMA_LIBNAME).$(DYLIBSUFFIX)
 RDMA_DYLIBNAME=$(LIB_DIR)/$(RDMA_LIBNAME).$(DYLIBSUFFIX)
 RDMA_STLIBNAME=$(LIB_DIR)/$(RDMA_LIBNAME).$(STLIBSUFFIX)
-RDMA_DYLIB_MAKE_CMD=$(CC) $(OPTIMIZATION) $(PLATFORM_FLAGS) -shared -Wl,-soname,$(RDMA_DYLIB_MAJOR_NAME)
+RDMA_DYLIB_MAKE_CMD=$(CC) $(PLATFORM_FLAGS) -shared -Wl,-soname,$(RDMA_DYLIB_MAJOR_NAME)
 
 USE_RDMA?=0
 
@@ -182,28 +182,63 @@ ifeq ($(USE_TLS),1)
   TLS_LDFLAGS+=-lssl -lcrypto
 endif
 
-ifeq ($(uname_S),FreeBSD)
-  LDFLAGS += -lm
-else ifeq ($(UNAME_S),SunOS)
-  ifeq ($(shell $(CC) -V 2>&1 | grep -iq 'sun\|studio' && echo true),true)
+USE_THREADS?=1
+ifeq ($(USE_THREADS),1)
+  CFLAGS+=-DVALKEY_USE_THREADS
+endif
+
+PTHREAD_FLAGS :=
+
+ifeq ($(uname_S),Linux)
+  ifeq ($(USE_THREADS),1)
+    PTHREAD_FLAGS += -pthread
+  endif
+else ifeq ($(uname_S),FreeBSD)
+  REAL_LDFLAGS += -lm
+  ifeq ($(USE_THREADS),1)
+    PTHREAD_FLAGS += -pthread
+  endif
+else ifeq ($(uname_S),SunOS)
+  # Solaris' default grep doesn't have -E so we need two checks
+  CC_VERSION := $(shell $(CC) -V 2>&1 || echo unknown)
+  ifneq (,$(findstring Sun C,$(CC_VERSION)))
+    HAVE_SUN_CC := 1
+  else ifneq (,$(findstring Studio,$(CC_VERSION)))
+    HAVE_SUN_CC := 1
+  endif
+
+  ifeq ($(HAVE_SUN_CC),1)
     SUN_SHARED_FLAG = -G
+    REAL_CFLAGS    += -mt
+    ifeq ($(USE_THREADS),1)
+      PTHREAD_FLAGS  += -mt
+    endif
   else
     SUN_SHARED_FLAG = -shared
+    ifeq ($(USE_THREADS),1)
+      PTHREAD_FLAGS  += -pthread
+    endif
   endif
   REAL_LDFLAGS += -ldl -lnsl -lsocket
-  DYLIB_MAKE_CMD = $(CC) $(OPTIMIZATION) $(SUN_SHARED_FLAG) -o $(DYLIBNAME) -h $(DYLIB_PATCH_NAME) $(LDFLAGS)
-  TLS_DYLIB_MAKE_CMD = $(CC) $(SUN_SHARED_FLAG) -o $(TLS_DYLIBNAME) -h $(TLS_DYLIB_PATCH_NAME) $(LDFLAGS) $(TLS_LDFLAGS)
+  DYLIB_MAKE_CMD = $(CC) $(SUN_SHARED_FLAG) -h $(DYLIB_PATCH_NAME)
+  TLS_DYLIB_MAKE_CMD = $(CC) $(SUN_SHARED_FLAG) -h $(TLS_DYLIB_PATCH_NAME)
 else ifeq ($(uname_S),Darwin)
+  ifeq ($(USE_THREADS),1)
+    PTHREAD_FLAGS += -pthread
+  endif
   DYLIBSUFFIX=dylib
   DYLIB_PATCH_NAME=$(LIBNAME).$(LIBVALKEY_MAJOR).$(LIBVALKEY_MINOR).$(LIBVALKEY_PATCH).$(DYLIBSUFFIX)
   DYLIB_MAJOR_NAME=$(LIBNAME).$(LIBVALKEY_MAJOR).$(DYLIBSUFFIX)
-  DYLIB_MAKE_CMD=$(CC) -dynamiclib -Wl,-install_name,$(PREFIX)/$(LIBRARY_PATH)/$(DYLIB_PATCH_NAME) -o $(DYLIBNAME) $(LDFLAGS)
+  DYLIB_MAKE_CMD=$(CC) -dynamiclib \
+    -Wl,-install_name,$(PREFIX)/$(LIBRARY_PATH)/$(DYLIB_PATCH_NAME)
   TLS_DYLIB_PATCH_NAME=$(TLS_LIBNAME).$(LIBVALKEY_MAJOR).$(LIBVALKEY_MINOR).$(LIBVALKEY_PATCH).$(DYLIBSUFFIX)
   TLS_DYLIB_MAJOR_NAME=$(TLS_LIBNAME).$(LIBVALKEY_MAJOR).$(DYLIBSUFFIX)
-  TLS_DYLIB_MAKE_CMD=$(CC) -dynamiclib -Wl,-install_name,$(PREFIX)/$(LIBRARY_PATH)/$(TLS_DYLIB_PATCH_NAME) -o $(TLS_DYLIBNAME) $(LDFLAGS) $(TLS_LDFLAGS)
-  DYLIB_PLUGIN=-Wl,-undefined -Wl,dynamic_lookup
+  TLS_DYLIB_MAKE_CMD=$(CC) -dynamiclib \
+    -Wl,-install_name,$(PREFIX)/$(LIBRARY_PATH)/$(TLS_DYLIB_PATCH_NAME)
 endif
 
+REAL_LDFLAGS += $(PTHREAD_FLAGS)
+
 all: dynamic static pkgconfig tests
 
 $(DYLIBNAME): $(OBJS) | $(LIB_DIR)
@@ -212,14 +247,16 @@ $(DYLIBNAME): $(OBJS) | $(LIB_DIR)
 $(STLIBNAME): $(OBJS) | $(LIB_DIR)
 	$(STLIB_MAKE_CMD) $(STLIBNAME) $(OBJS)
 
-$(TLS_DYLIBNAME): $(TLS_OBJS)
-	$(TLS_DYLIB_MAKE_CMD) $(DYLIB_PLUGIN) -o $(TLS_DYLIBNAME) $(TLS_OBJS) $(REAL_LDFLAGS) $(LDFLAGS) $(TLS_LDFLAGS)
+$(TLS_DYLIBNAME): $(TLS_OBJS) $(DYLIBNAME) | $(LIB_DIR)
+	$(TLS_DYLIB_MAKE_CMD) -o $(TLS_DYLIBNAME) \
+	    $(TLS_OBJS) $(REAL_LDFLAGS) $(DYLIBNAME) $(TLS_LDFLAGS)
 
 $(TLS_STLIBNAME): $(TLS_OBJS)
 	$(STLIB_MAKE_CMD) $(TLS_STLIBNAME) $(TLS_OBJS)
 
-$(RDMA_DYLIBNAME): $(RDMA_OBJS)
-	$(RDMA_DYLIB_MAKE_CMD) $(DYLIB_PLUGIN) -o $(RDMA_DYLIBNAME) $(RDMA_OBJS) $(REAL_LDFLAGS) $(LDFLAGS) $(RDMA_LDFLAGS)
+$(RDMA_DYLIBNAME): $(RDMA_OBJS) $(DYLIBNAME) | $(LIB_DIR)
+	$(RDMA_DYLIB_MAKE_CMD) -o $(RDMA_DYLIBNAME) \
+	    $(RDMA_OBJS) $(REAL_LDFLAGS) $(DYLIBNAME) $(RDMA_LDFLAGS)
 
 $(RDMA_STLIBNAME): $(RDMA_OBJS)
 	$(STLIB_MAKE_CMD) $(RDMA_STLIBNAME) $(RDMA_OBJS)
@@ -230,8 +267,8 @@ $(OBJ_DIR)/%.o: $(SRC_DIR)/%.c | $(OBJ_DIR)
 $(OBJ_DIR)/%.o: $(TEST_DIR)/%.c | $(OBJ_DIR)
 	$(CC) -std=c99 -pedantic $(REAL_CFLAGS) -I$(INCLUDE_DIR) -I$(SDS_INCLUDE_DIR) -I$(DICT_INCLUDE_DIR) -I$(SRC_DIR) -MMD -MP -c $< -o $@
 
-$(TEST_DIR)/%: $(OBJ_DIR)/%.o $(STLIBNAME)
-	$(CC) -o $@ $< $(RDMA_STLIB) $(STLIBNAME) $(TLS_STLIB) $(LDFLAGS) $(TEST_LDFLAGS)
+$(TEST_DIR)/%: $(OBJ_DIR)/%.o $(STLIBNAME) $(TLS_STLIB)
+	$(CC) -o $@ $< $(RDMA_STLIB) $(STLIBNAME) $(TLS_STLIB) $(REAL_LDFLAGS) $(TEST_LDFLAGS)
 
 $(OBJ_DIR):
 	mkdir -p $(OBJ_DIR)
@@ -249,7 +286,12 @@ pkgconfig: $(PKGCONFNAME) $(TLS_PKGCONF) $(RDMA_PKGCONF)
 
 TEST_LDFLAGS = $(TLS_LDFLAGS) $(RDMA_LDFLAGS)
 ifeq ($(USE_TLS),1)
-  TEST_LDFLAGS += -pthread
+  # Tests need pthreads if TLS is enabled, but only add it once
+  ifeq ($(HAVE_SUN_CC),1)
+    TEST_LDFLAGS += -mt
+  else ifeq (,$(findstring -pthread,$(REAL_LDFLAGS) $(TEST_LDFLAGS)))
+    TEST_LDFLAGS += -pthread
+  endif
 endif
 ifeq ($(TEST_ASYNC),1)
     TEST_LDFLAGS += -levent