{

if ( !module )

return false;

#if !__TBB_DYNAMIC_LOAD_ENABLED /* only __TBB_WEAK_SYMBOLS_PRESENT is defined */

if ( !dlsym ) return false;

#endif /* !__TBB_DYNAMIC_LOAD_ENABLED */

const size_t n_desc=20; // Usually we don't have more than 20 descriptors per library

LIBRARY_ASSERT( required <= n_desc, "Too many descriptors is required" );

if ( required > n_desc ) return false;

pointer_to_handler h[n_desc];

for ( size_t k = 0; k < required; ++k ) {

dynamic_link_descriptor const & desc = descriptors[k];

pointer_to_handler addr = (pointer_to_handler)dlsym( module, desc.name );

if ( !addr ) {

return false;

}

h[k] = addr;

}

// Commit the entry points.

// Cannot use memset here, because the writes must be atomic.

for( size_t k = 0; k < required; ++k )

*descriptors[k].handler = h[k];

return true;

dynamic_link_handle tmp_handle = NULL;

TCHAR wlibrary[256];

if ( MultiByteToWideChar(CP_UTF8, 0, library, -1, wlibrary, 255) == 0 ) return false;

if ( flags & DYNAMIC_LINK_LOAD )

tmp_handle = LoadPackagedLibrary( wlibrary, 0 );

if (tmp_handle != NULL){

return resolve_symbols(tmp_handle, descriptors, required);

}else{

return false;

}

size_t my_val;

pthread_spinlock_t my_lock;

public:

void init() {

my_val = 0;

pthread_assert( pthread_spin_init( &my_lock, PTHREAD_PROCESS_PRIVATE ), "pthread_spin_init failed" );

}

size_t operator++(int) {

pthread_assert( pthread_spin_lock( &my_lock ), "pthread_spin_lock failed" );

size_t prev_val = my_val++;

pthread_assert( pthread_spin_unlock( &my_lock ), "pthread_spin_unlock failed" );

return prev_val;

}

operator size_t() {

pthread_assert( pthread_spin_lock( &my_lock ), "pthread_spin_lock failed" );

size_t val = my_val;

pthread_assert( pthread_spin_unlock( &my_lock ), "pthread_spin_unlock failed" );

return val;

}

~atomic_incrementer() {

pthread_assert( pthread_spin_destroy( &my_lock ), "pthread_spin_destroy failed" );

}

atomic_incrementer my_size;

dynamic_link_handle my_handles[MAX_LOADED_MODULES];

void init() {

init_atomic_incrementer( my_size );

}

void add(const dynamic_link_handle &handle) {

const size_t ind = my_size++;

LIBRARY_ASSERT( ind < MAX_LOADED_MODULES, "Too many modules are loaded" );

my_handles[ind] = handle;

}

void free() {

const size_t size = my_size;

for (size_t i=0; i<size; ++i)

dynamic_unlink( my_handles[i] );

}

#if _WIN32

// Get handle of our DLL first.

HMODULE handle;

BOOL brc = GetModuleHandleEx(

GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,

(LPCSTR)( & dynamic_link ), // any function inside the library can be used for the address

& handle

);

if ( !brc ) { // Error occurred.

int err = GetLastError();

DYNAMIC_LINK_WARNING( dl_sys_fail, "GetModuleHandleEx", err );

return;

}

// Now get path to our DLL.

DWORD drc = GetModuleFileName( handle, ap_data._path, static_cast< DWORD >( PATH_MAX ) );

if ( drc == 0 ) { // Error occurred.

int err = GetLastError();

DYNAMIC_LINK_WARNING( dl_sys_fail, "GetModuleFileName", err );

return;

}

if ( drc >= PATH_MAX ) { // Buffer too short.

DYNAMIC_LINK_WARNING( dl_buff_too_small );

return;

}

// Find the position of the last backslash.

char *backslash = strrchr( ap_data._path, '\\' );

if ( !backslash ) { // Backslash not found.

LIBRARY_ASSERT( backslash!=NULL, "Unbelievable.");

return;

}

LIBRARY_ASSERT( backslash >= ap_data._path, "Unbelievable.");

ap_data._len = (size_t)(backslash - ap_data._path) + 1;

*(backslash+1) = 0;

#else

// Get the library path

Dl_info dlinfo;

int res = dladdr( (void*)&dynamic_link, &dlinfo ); // any function inside the library can be used for the address

if ( !res ) {

char const * err = dlerror();

DYNAMIC_LINK_WARNING( dl_sys_fail, "dladdr", err );

return;

} else {

LIBRARY_ASSERT( dlinfo.dli_fname!=NULL, "Unbelievable." );

}

char const *slash = strrchr( dlinfo.dli_fname, '/' );

size_t fname_len=0;

if ( slash ) {

LIBRARY_ASSERT( slash >= dlinfo.dli_fname, "Unbelievable.");

fname_len = (size_t)(slash - dlinfo.dli_fname) + 1;

}

size_t rc;

if ( dlinfo.dli_fname[0]=='/' ) {

// The library path is absolute

rc = 0;

ap_data._len = 0;

} else {

// The library path is relative so get the current working directory

if ( !getcwd( ap_data._path, sizeof(ap_data._path)/sizeof(ap_data._path[0]) ) ) {

DYNAMIC_LINK_WARNING( dl_buff_too_small );

return;

}

ap_data._len = strlen( ap_data._path );

ap_data._path[ap_data._len++]='/';

rc = ap_data._len;

}

if ( fname_len>0 ) {

if ( ap_data._len>PATH_MAX ) {

DYNAMIC_LINK_WARNING( dl_buff_too_small );

ap_data._len=0;

return;

}

strncpy( ap_data._path+rc, dlinfo.dli_fname, fname_len );

ap_data._len += fname_len;

ap_data._path[ap_data._len]=0;

}

#endif /* _WIN32 */

if ( !ap_data._len )

return 0;

size_t name_len = strlen( name );

size_t full_len = name_len+ap_data._len;

if ( full_len < len ) {

strncpy( path, ap_data._path, ap_data._len );

memcpy( path+ap_data._len, name, name_len );

path[full_len] = 0;

}

return full_len;

#if __TBB_DYNAMIC_LOAD_ENABLED

atomic_once( &init_dl_data, init_dl_data_state );

#endif

static_init_dl_data_t() {

init_dynamic_link_data();

}

{

// Check if the required entries are present in what was loaded into our process.

for ( size_t k = 0; k < required; ++k )

if ( !descriptors[k].ptr )

return false;

// Commit the entry points.

for ( size_t k = 0; k < required; ++k )

*descriptors[k].handler = (pointer_to_handler) descriptors[k].ptr;

return true;

#if !__TBB_DYNAMIC_LOAD_ENABLED /* only __TBB_WEAK_SYMBOLS_PRESENT is defined */

if ( !dlclose ) return;

#endif

if ( handle ) {

dlclose( handle );

}

#if __TBB_DYNAMIC_LOAD_ENABLED

handles.free();

#endif

// It is supposed that all symbols are from the only one library

// The library has been loaded by another module and contains at least one requested symbol.

// But after we obtained the symbol the library can be unloaded by another thread

// invalidating our symbol. Therefore we need to pin the library in memory.

dynamic_link_handle library_handle = 0;

Dl_info info;

// Get library's name from earlier found symbol

if ( dladdr( (void*)*desc.handler, &info ) ) {

// Pin the library

library_handle = dlopen( info.dli_fname, RTLD_LAZY );

if ( library_handle ) {

// If original library was unloaded before we pinned it

// and then another module loaded in its place, the earlier

// found symbol would become invalid. So revalidate them.

if ( !resolve_symbols( library_handle, descriptors, required ) ) {

// Wrong library.

dynamic_unlink(library_handle);

library_handle = 0;

}

} else {

char const * err = dlerror();

DYNAMIC_LINK_WARNING( dl_lib_not_found, info.dli_fname, err );

}

}

// else the library has been unloaded by another thread

return library_handle;

::tbb::internal::suppress_unused_warning( library );

dynamic_link_handle library_handle;

#if _WIN32

if ( GetModuleHandleEx( 0, library, &library_handle ) ) {

if ( resolve_symbols( library_handle, descriptors, required ) )

return library_handle;

else

FreeLibrary( library_handle );

}

#else /* _WIN32 */

#if !__TBB_DYNAMIC_LOAD_ENABLED /* only __TBB_WEAK_SYMBOLS_PRESENT is defined */

if ( !dlopen ) return 0;

#endif /* !__TBB_DYNAMIC_LOAD_ENABLED */

library_handle = dlopen( NULL, RTLD_LAZY );

#if !__ANDROID__

// On Android dlopen( NULL ) returns NULL if it is called during dynamic module initialization.

LIBRARY_ASSERT( library_handle, "The handle for the main program is NULL" );

#endif

#if __TBB_DYNAMIC_LOAD_ENABLED

// Check existence of the first symbol only, then use it to find the library and load all necessary symbols.

pointer_to_handler handler;

dynamic_link_descriptor desc;

desc.name = descriptors[0].name;

desc.handler = &handler;

if ( resolve_symbols( library_handle, &desc, 1 ) ) {

dynamic_unlink( library_handle );

return pin_symbols( desc, descriptors, required );

}

#else /* only __TBB_WEAK_SYMBOLS_PRESENT is defined */

if ( resolve_symbols( library_handle, descriptors, required ) )

return library_handle;

#endif

dynamic_unlink( library_handle );

#endif /* _WIN32 */

return 0;

LIBRARY_ASSERT( src, "The library handle to store must be non-zero" );

if ( dst )

*dst = src;

#if __TBB_DYNAMIC_LOAD_ENABLED

else

handles.add( src );

#endif /* __TBB_DYNAMIC_LOAD_ENABLED */

::tbb::internal::suppress_unused_warning( library, descriptors, required );

#if __TBB_DYNAMIC_LOAD_ENABLED

size_t const len = PATH_MAX + 1;

char path[ len ];

size_t rc = abs_path( library, path, len );

if ( 0 < rc && rc < len ) {

#if _WIN32

// Prevent Windows from displaying silly message boxes if it fails to load library

// (e.g. because of MS runtime problems - one of those crazy manifest related ones)

UINT prev_mode = SetErrorMode (SEM_FAILCRITICALERRORS);

#endif /* _WIN32 */

dynamic_link_handle library_handle = dlopen( path, RTLD_LAZY );

#if _WIN32

SetErrorMode (prev_mode);

#endif /* _WIN32 */

if( library_handle ) {

if( !resolve_symbols( library_handle, descriptors, required ) ) {

// The loaded library does not contain all the expected entry points

dynamic_unlink( library_handle );

library_handle = NULL;

}

} else

DYNAMIC_LINK_WARNING( dl_lib_not_found, path, dlerror() );

return library_handle;

} else if ( rc>=len )

DYNAMIC_LINK_WARNING( dl_buff_too_small );

// rc == 0 means failing of init_ap_data so the warning has already been issued.

#endif /* __TBB_DYNAMIC_LOAD_ENABLED */

return 0;

init_dynamic_link_data();

// TODO: May global_symbols_link find weak symbols?

dynamic_link_handle library_handle = ( flags & DYNAMIC_LINK_GLOBAL ) ? global_symbols_link( library, descriptors, required ) : 0;

if ( !library_handle && ( flags & DYNAMIC_LINK_LOAD ) )

library_handle = dynamic_load( library, descriptors, required );

if ( !library_handle && ( flags & DYNAMIC_LINK_WEAK ) )

return weak_symbol_link( descriptors, required );

if ( library_handle ) {

save_library_handle( library_handle, handle );

return true;

}

return false;

if ( handle )

*handle=0;

return false;