Extend test dynamic link (#1724)

Author: aleksei-fedotov

include/oneapi/tbb/detail/_assert.h

@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2022 Intel Corporation
+    Copyright (c) 2005-2025 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -30,7 +30,8 @@ namespace r1 {
 /** Normally called from __TBB_ASSERT macro.
   If assertion handler is null, print message for assertion failure and abort.
   Otherwise call the assertion handler. */
-TBB_EXPORT void __TBB_EXPORTED_FUNC assertion_failure(const char* location, int line, const char* expression, const char* comment);
+TBB_EXPORT void __TBB_EXPORTED_FUNC assertion_failure(const char *location, int line,
+                                                      const char *expression, const char *comment);
 #if __TBBMALLOC_BUILD
 }} // namespaces rml::internal
 #else

src/tbb/dynamic_link.cpp

@@ -136,12 +136,17 @@ namespace r1 {
         const char* str = nullptr;
         // Note: dlerr_t depends on OS: it is char const * on Linux* and macOS*, int on Windows*.
 #if _WIN32
-        #define DLERROR_SPECIFIER "%d"
+#if __INTEL_LLVM_COMPILER
+// Suppress the incorrect warning about the format specifier for the unsigned long long type.
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wformat"
+#endif
+        #define DLERROR_SPECIFIER "%ul"
         typedef DWORD dlerr_t;
 #else
         #define DLERROR_SPECIFIER "%s"
         typedef const char* dlerr_t;
-#endif
+#endif                          // _WIN32
         dlerr_t error = 0;
 
         std::va_list args;
@@ -155,7 +160,10 @@ namespace r1 {
                         DLERROR_SPECIFIER "\n", prefix, str, error);
             break;
         case dl_sym_not_found:     // char const * sym, dlerr_t err:
-            // TODO: Print not found symbol once it is used by the implementation
+            str = va_arg(args, const char*);
+            error = va_arg(args, dlerr_t);
+            TBB_FPRINTF(stderr, "%s The symbol \"%s\" was not resolved. System error: "
+                        DLERROR_SPECIFIER "\n", prefix, str, error);
             break;
         case dl_sys_fail:
             str = va_arg(args, const char*);
@@ -216,6 +224,9 @@ namespace r1 {
         va_end(args);
     } // library_warning
 #undef DLERROR_SPECIFIER
+#if _WIN32 && __INTEL_LLVM_COMPILER
+#pragma GCC diagnostic pop
+#endif
 #else
     static void dynamic_link_warning( int code, ... ) {
         suppress_unused_warning(code);
@@ -224,6 +235,8 @@ namespace r1 {
 
 #elif defined(DYNAMIC_LINK_WARNING)
 #define __DYNAMIC_LINK_REPORT_SIGNATURE_ERRORS 1
+#else
+#define DYNAMIC_LINK_WARNING(...) (void)0
 #endif /* !defined(DYNAMIC_LINK_WARNING) && !__TBB_WIN8UI_SUPPORT && __TBB_DYNAMIC_LOAD_ENABLED */
 
     static bool resolve_symbols( dynamic_link_handle module, const dynamic_link_descriptor descriptors[], std::size_t required )
@@ -244,6 +257,7 @@ namespace r1 {
             dynamic_link_descriptor const & desc = descriptors[k];
             pointer_to_handler addr = (pointer_to_handler)dlsym( module, desc.name );
             if ( !addr ) {
+                DYNAMIC_LINK_WARNING( dl_sym_not_found, desc.name, dlerror() );
                 return false;
             }
             h[k] = addr;
@@ -426,7 +440,7 @@ namespace r1 {
                     otherwise -- Ok, number of characters (incl. terminating null) written to buffer.
     */
     static std::size_t abs_path( char const * name, char * path, std::size_t len ) {
-        if ( ap_data._len == 0 )
+        if ( !name || ap_data._len == 0 )
             return 0;
 
         std::size_t name_len = std::strlen( name );

test/CMakeLists.txt

@@ -420,7 +420,18 @@ if (TARGET TBB::tbb)
     if (NOT TBB_TCM_TESTING)
         tbb_add_test(SUBDIR tbb NAME test_arena_priorities DEPENDENCIES TBB::tbb)
     endif()
-    tbb_add_test(SUBDIR tbb NAME test_dynamic_link DEPENDENCIES TBB::tbb)
+
+    tbb_add_test(SUBDIR tbb NAME test_dynamic_link)
+    add_dependencies(test_dynamic_link TBB::tbb)
+    target_include_directories(test_dynamic_link PRIVATE
+        $<TARGET_PROPERTY:TBB::tbb,INTERFACE_INCLUDE_DIRECTORIES>)
+    set_property(TARGET test_dynamic_link PROPERTY BUILD_RPATH_USE_ORIGIN TRUE)
+    set_property(TARGET test_dynamic_link PROPERTY BUILD_RPATH "$ORIGIN")
+    target_compile_definitions(test_dynamic_link PRIVATE "TBBLIB_NAME=\"$<TARGET_FILE_NAME:TBB::tbb>\"")
+    # Making unsigned library which the test fails loading
+    add_library(stub_unsigned SHARED ${CMAKE_CURRENT_SOURCE_DIR}/tbb/stub_unsigned_lib.cpp)
+    add_dependencies(test_dynamic_link stub_unsigned)
+
     if (LINKER_HAS_NO_AS_NEEDED)
         # The linker may not detect a dependency on pthread in static variable constructors.
         target_link_libraries(test_dynamic_link PRIVATE "-Wl,--no-as-needed")

test/tbb/stub_unsigned_lib.cpp

@@ -0,0 +1,43 @@
+/*
+    Copyright (c) 2025 Intel Corporation
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+//! \file stub_unsigned_lib.cpp
+//! \brief Test for [internal] functionality
+
+#if _WIN32 || _WIN64
+// Make sure the symbol is visible
+#define STUB_EXPORT __declspec(dllexport)
+#else
+// On other platforms check the branch when symbol cannot be resolved by hiding it
+#define STUB_EXPORT __attribute__ ((visibility ("hidden")))
+#endif
+
+#include <cstdlib>
+
+extern "C" {
+
+static int dummy = []() {
+#if _WIN32
+    // Make sure the library is not loaded on Windows in test dynamic link
+    std::abort();
+#endif
+    return 1;
+}();
+
+STUB_EXPORT void foo() {
+    std::abort();               // Test dynamic link should never call this function
+}
+}

test/tbb/test_dynamic_link.cpp

@@ -1,5 +1,5 @@
 /*
-    Copyright (c) 2005-2024 Intel Corporation
+    Copyright (c) 2005-2025 Intel Corporation
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -21,8 +21,13 @@
 #define _CRT_SECURE_NO_WARNINGS
 #endif
 
+#define __TBB_NO_IMPLICIT_LINKAGE 1
+
 #include "common/test.h"
 
+// Out-of-line TBB assertion handling routines are instantiated here
+#include "../../src/tbb/assert_impl.h"
+
 enum FOO_TYPE {
     FOO_DUMMY,
     FOO_IMPLEMENTATION
@@ -42,31 +47,43 @@ FOO_TYPE dummy_foo1() { return FOO_DUMMY; }
 FOO_TYPE dummy_foo2() { return FOO_DUMMY; }
 
 #include "oneapi/tbb/detail/_config.h"
+#include "oneapi/tbb/version.h"
+
 // Suppress the weak symbol mechanism to avoid surplus compiler warnings.
 #ifdef __TBB_WEAK_SYMBOLS_PRESENT
 #undef __TBB_WEAK_SYMBOLS_PRESENT
 #endif
-#include "src/tbb/dynamic_link.h"
 
-#if __TBB_DYNAMIC_LOAD_ENABLED
-// Handlers.
-static FOO_TYPE (*foo1_handler)() = &dummy_foo1;
-static FOO_TYPE (*foo2_handler)() = &dummy_foo2;
-
-// Table describing how to link the handlers.
-static const tbb::detail::r1::dynamic_link_descriptor LinkTable[] = {
-    { "foo1", (tbb::detail::r1::pointer_to_handler*)(void*)(&foo1_handler) },
-    { "foo2", (tbb::detail::r1::pointer_to_handler*)(void*)(&foo2_handler) }
-};
-#endif
 
-// The direct include since we want to test internal functionality.
+#ifndef TBB_DYNAMIC_LINK_WARNING
+#define TBB_DYNAMIC_LINK_WARNING 1
+#endif
+#ifdef __TBB_SKIP_DEPENDENCY_SIGNATURE_VERIFICATION
+#warning "Signature verification must not be turned off to fully test dynamic link functionality"
+#endif
+// The direct include since we want to test internal functionality
 #include "src/tbb/dynamic_link.cpp"
+
+
 #include "common/utils.h"
 #include "common/utils_dynamic_libs.h"
 
+#include <cstdio>               // for std::snprintf
+#include <cstring>              // for std::strcmp
+
 void test_dynamic_link(const char* lib_name) {
 #if __TBB_DYNAMIC_LOAD_ENABLED
+    // Handlers.
+    static FOO_TYPE (*foo1_handler)() = nullptr;
+    static FOO_TYPE (*foo2_handler)() = nullptr;
+    foo1_handler = &dummy_foo1;
+    foo2_handler = &dummy_foo2;
+
+    // Table describing how to link the handlers.
+    static const tbb::detail::r1::dynamic_link_descriptor LinkTable[] = {
+        { "foo1", (tbb::detail::r1::pointer_to_handler*)(void*)(&foo1_handler) },
+        { "foo2", (tbb::detail::r1::pointer_to_handler*)(void*)(&foo2_handler) }
+    };
 #if !_WIN32
     // Check if the executable exports its symbols.
     REQUIRE_MESSAGE((utils::GetAddress(utils::OpenLibrary(nullptr), "foo1") && utils::GetAddress(utils::OpenLibrary(nullptr), "foo2")),
@@ -80,9 +97,10 @@ void test_dynamic_link(const char* lib_name) {
     if (tbb::detail::r1::dynamic_link(lib_name, LinkTable, sizeof(LinkTable) / sizeof(LinkTable[0]))) {
         REQUIRE_MESSAGE((foo1_handler && foo2_handler), "The symbols are corrupted by dynamic_link");
         REQUIRE_MESSAGE((foo1_handler() == FOO_IMPLEMENTATION && foo2_handler() == FOO_IMPLEMENTATION),
-                "dynamic_link returned the successful code but symbol(s) are wrong");
+                        "dynamic_link returned the successful code but symbol(s) are wrong");
     } else {
-        REQUIRE_MESSAGE((foo1_handler == dummy_foo1 && foo2_handler == dummy_foo2), "The symbols are corrupted by dynamic_link");
+        REQUIRE_MESSAGE((foo1_handler == &dummy_foo1 && foo2_handler == &dummy_foo2),
+                        "The symbols are corrupted by dynamic_link");
     }
 #else
     utils::suppress_unused_warning(lib_name);
@@ -97,6 +115,92 @@ TEST_CASE("Test dynamic_link with non-existing library") {
 
 //! Testing dynamic_link
 //! \brief \ref error_guessing
-TEST_CASE("Test dynamic_link") {
+TEST_CASE("Test dynamic_link corner cases") {
+    test_dynamic_link(nullptr);
     test_dynamic_link("");
 }
+
+
+#if __TBB_DYNAMIC_LOAD_ENABLED
+
+#if !__TBB_WIN8UI_SUPPORT
+//! Testing dynamic_link with existing library
+//! \brief \ref requirement
+TEST_CASE("Test dynamic_link with existing library") {
+  // Check that not-yet-linked library is found and loaded even without specifying absolute path to
+  // it. On Windows, signature validation is performed in addition.
+#if _WIN32
+    // Well known signed Windows library that exist in every distribution
+    const char* lib_name = "user32.dll";
+    const char* symbol = "MessageBoxA";
+    int (*handler)(void * /*hWnd*/, const char * /*lpText*/, const char * /*lpCaption*/,
+                   unsigned int /*uType*/) = nullptr;
+#else
+    const char* lib_name = TBBLIB_NAME; // On Linux it is the name of the library itself
+    const char* symbol = "TBB_runtime_version";
+    static const char* (*handler)() = nullptr;
+#endif
+    static const tbb::detail::r1::dynamic_link_descriptor table[] = {
+        { symbol, (tbb::detail::r1::pointer_to_handler*)(void*)(&handler) },
+    };
+
+    constexpr int load_flags =
+        tbb::detail::r1::DYNAMIC_LINK_DEFAULT & ~tbb::detail::r1::DYNAMIC_LINK_BUILD_ABSOLUTE_PATH;
+    const bool link_result = tbb::detail::r1::dynamic_link(lib_name, table,
+                                                           sizeof(table) / sizeof(table[0]),
+                                                           /*handle*/nullptr, load_flags);
+    char msg[128] = {0};
+    std::snprintf(msg, sizeof(msg) / sizeof(msg[0]), "The library \"%s\" was not loaded", lib_name);
+    REQUIRE_MESSAGE(link_result, msg);
+    REQUIRE_MESSAGE(handler, "The symbol was not found.");
+#if !_WIN32
+    REQUIRE_MESSAGE(0 == std::strcmp(handler(), TBB_VERSION_STRING),
+                    "dynamic_link returned successful code but symbol returned incorrect result");
+#endif
+}
+#endif                          // !__TBB_WIN8UI_SUPPORT
+
+//! Testing dynamic_link with stub library known to be unsigned (on Windows) and having no exported
+//! symbols (on Linux)
+// \brief \ref requirement
+TEST_CASE("Test dynamic_link with bad library") {
+    const int size = PATH_MAX + 1;
+    const char* lib_name = TEST_LIBRARY_NAME("stub_unsigned");
+    char path[size] = {0};
+    const int msg_size = size + 128; // Path to the file + message
+    char msg[msg_size] = {0};
+
+#if !__TBB_WIN8UI_SUPPORT
+    const std::size_t len = tbb::detail::r1::abs_path(lib_name, path, sizeof(path));
+    REQUIRE_MESSAGE((0 < len && len <= PATH_MAX), "The path to the library is not built");
+    std::snprintf(msg, msg_size, "Test prerequisite is not held - the path \"%s\" must exist", path);
+    REQUIRE_MESSAGE(tbb::detail::r1::file_exists(path), msg);
+#endif
+
+    // The library exists, check that it will not be loaded.
+    void (*handler)() = nullptr;
+    static const tbb::detail::r1::dynamic_link_descriptor table[] = {
+        { "foo", (tbb::detail::r1::pointer_to_handler*)(void*)(&handler) },
+    };
+
+    // Specify library name without absolute path to test that it still can be found because it
+    // resides in the application (i.e. test) directory
+    constexpr int load_flags =
+        tbb::detail::r1::DYNAMIC_LINK_DEFAULT & ~tbb::detail::r1::DYNAMIC_LINK_BUILD_ABSOLUTE_PATH;
+    const bool link_result = tbb::detail::r1::dynamic_link(lib_name, table,
+                                                           sizeof(table) / sizeof(table[0]),
+                                                           /*handle*/nullptr, load_flags);
+    std::snprintf(msg, msg_size, "The library \"%s\" was loaded but should not have been.", path);
+
+    // Expectation is that the library will not be loaded because:
+    // a) On Windows the library is unsigned
+    // b) On Linux the library does not have exported symbols
+    const bool expected_link_result = false;
+
+    REQUIRE_MESSAGE(expected_link_result == link_result, msg);
+    REQUIRE_MESSAGE(nullptr == handler, "The symbol should not be changed.");
+    // TODO: Verify the warning message contains "TBB dynamic link warning: The module
+    // \".*stub_unsigned.*.dll\" is unsigned or has invalid signature."
+}
+
+#endif // __TBB_DYNAMIC_LOAD_ENABLED