35 #define dlopen( name, flags ) LoadLibrary( name ) 36 #define dlsym( handle, name ) GetProcAddress( handle, name ) 37 #define dlclose( handle ) ( ! FreeLibrary( handle ) ) 38 #define dlerror() GetLastError() 40 #define PATH_MAX MAX_PATH 50 #if __TBB_WEAK_SYMBOLS_PRESENT && !__TBB_DYNAMIC_LOAD_ENABLED 59 #define __USE_TBB_ATOMICS ( !(__linux__&&__ia64__) || __TBB_BUILD ) 60 #define __USE_STATIC_DL_INIT ( !__ANDROID__ ) 62 #if !__USE_TBB_ATOMICS 110 #if __TBB_WEAK_SYMBOLS_PRESENT || __TBB_DYNAMIC_LOAD_ENABLED 112 #if !defined(DYNAMIC_LINK_WARNING) && !__TBB_WIN8UI_SUPPORT && __TBB_DYNAMIC_LOAD_ENABLED 114 #define DYNAMIC_LINK_WARNING dynamic_link_warning 125 #if !__TBB_DYNAMIC_LOAD_ENABLED 126 if ( !dlsym )
return false;
129 const size_t n_desc=20;
130 LIBRARY_ASSERT( required <= n_desc,
"Too many descriptors is required" );
131 if ( required > n_desc )
return false;
134 for (
size_t k = 0; k < required; ++k ) {
145 for(
size_t k = 0; k < required; ++k )
146 *descriptors[k].handler =
h[k];
150 #if __TBB_WIN8UI_SUPPORT 154 if ( MultiByteToWideChar(CP_UTF8, 0, library, -1, wlibrary, 255) == 0 )
return false;
156 tmp_handle = LoadPackagedLibrary( wlibrary, 0 );
157 if (tmp_handle != NULL){
158 return resolve_symbols(tmp_handle, descriptors, required);
166 #if __TBB_DYNAMIC_LOAD_ENABLED 189 #define MAX_LOADED_MODULES 8 // The number of maximum possible modules which can be loaded 191 #if __USE_TBB_ATOMICS 192 typedef ::tbb::atomic<size_t> atomic_incrementer;
193 void init_atomic_incrementer( atomic_incrementer & ) {}
198 #define ATOMIC_ONCE_DECL( var ) tbb::atomic< tbb::internal::do_once_state > var 200 static void pthread_assert(
int error_code,
const char* msg ) {
204 class atomic_incrementer {
206 pthread_spinlock_t my_lock;
210 pthread_assert( pthread_spin_init( &my_lock, PTHREAD_PROCESS_PRIVATE ),
"pthread_spin_init failed" );
212 size_t operator++(
int) {
213 pthread_assert( pthread_spin_lock( &my_lock ),
"pthread_spin_lock failed" );
214 size_t prev_val = my_val++;
215 pthread_assert( pthread_spin_unlock( &my_lock ),
"pthread_spin_unlock failed" );
219 pthread_assert( pthread_spin_lock( &my_lock ),
"pthread_spin_lock failed" );
221 pthread_assert( pthread_spin_unlock( &my_lock ),
"pthread_spin_unlock failed" );
224 ~atomic_incrementer() {
225 pthread_assert( pthread_spin_destroy( &my_lock ),
"pthread_spin_destroy failed" );
229 void init_atomic_incrementer( atomic_incrementer &r ) {
233 static void atomic_once(
void( *func ) (), pthread_once_t &once_state ) {
234 pthread_assert( pthread_once( &once_state, func ),
"pthread_once failed" );
236 #define ATOMIC_ONCE_DECL( var ) pthread_once_t var = PTHREAD_ONCE_INIT 240 atomic_incrementer my_size;
244 init_atomic_incrementer( my_size );
248 const size_t ind = my_size++;
249 LIBRARY_ASSERT( ind < MAX_LOADED_MODULES,
"Too many modules are loaded" );
250 my_handles[ind] = handle;
254 const size_t size = my_size;
255 for (
size_t i=0; i<
size; ++i)
260 ATOMIC_ONCE_DECL( init_dl_data_state );
262 static struct ap_data_t {
267 static void init_ap_data() {
271 BOOL brc = GetModuleHandleEx(
272 GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
277 int err = GetLastError();
278 DYNAMIC_LINK_WARNING(
dl_sys_fail,
"GetModuleHandleEx", err );
282 DWORD drc = GetModuleFileName( handle, ap_data._path, static_cast< DWORD >(
PATH_MAX ) );
284 int err = GetLastError();
285 DYNAMIC_LINK_WARNING(
dl_sys_fail,
"GetModuleFileName", err );
293 char *backslash = strrchr( ap_data._path,
'\\' );
300 ap_data._len = (size_t)(backslash - ap_data._path) + 1;
307 char const * err = dlerror();
308 DYNAMIC_LINK_WARNING(
dl_sys_fail,
"dladdr", err );
314 char const *slash = strrchr( dlinfo.dli_fname,
'/' );
318 fname_len = (size_t)(slash - dlinfo.dli_fname) + 1;
322 if ( dlinfo.dli_fname[0]==
'/' ) {
328 if ( !getcwd( ap_data._path,
sizeof(ap_data._path)/
sizeof(ap_data._path[0]) ) ) {
332 ap_data._len = strlen( ap_data._path );
333 ap_data._path[ap_data._len++]=
'/';
343 strncpy( ap_data._path+rc, dlinfo.dli_fname, fname_len );
344 ap_data._len += fname_len;
345 ap_data._path[ap_data._len]=0;
350 static void init_dl_data() {
367 static size_t abs_path(
char const *
name,
char * path,
size_t len ) {
368 if ( ap_data._len == 0 )
371 size_t name_len = strlen(
name );
372 size_t full_len = name_len+ap_data._len;
373 if ( full_len < len ) {
375 strcpy( path, ap_data._path );
376 strcat( path,
name );
380 #endif // __TBB_DYNAMIC_LOAD_ENABLED 382 void init_dynamic_link_data() {
383 #if __TBB_DYNAMIC_LOAD_ENABLED 384 atomic_once( &init_dl_data, init_dl_data_state );
388 #if __USE_STATIC_DL_INIT 392 static struct static_init_dl_data_t {
393 static_init_dl_data_t() {
394 init_dynamic_link_data();
396 } static_init_dl_data;
399 #if __TBB_WEAK_SYMBOLS_PRESENT 403 for (
size_t k = 0; k < required; ++k )
404 if ( !descriptors[k].ptr )
407 for (
size_t k = 0; k < required; ++k )
418 #if !__TBB_DYNAMIC_LOAD_ENABLED 419 if ( !dlclose )
return;
427 #if __TBB_DYNAMIC_LOAD_ENABLED 433 #if __TBB_DYNAMIC_LOAD_ENABLED 442 if ( dladdr( (
void*)*desc.
handler, &info ) ) {
444 library_handle = dlopen( info.dli_fname, RTLD_LAZY );
445 if ( library_handle ) {
449 if ( !resolve_symbols( library_handle, descriptors, required ) ) {
455 char const * err = dlerror();
460 return library_handle;
469 if ( GetModuleHandleEx( 0, library, &library_handle ) ) {
470 if ( resolve_symbols( library_handle, descriptors, required ) )
471 return library_handle;
473 FreeLibrary( library_handle );
476 #if !__TBB_DYNAMIC_LOAD_ENABLED 477 if ( !dlopen )
return 0;
479 library_handle = dlopen( NULL, RTLD_LAZY );
482 LIBRARY_ASSERT( library_handle,
"The handle for the main program is NULL" );
484 #if __TBB_DYNAMIC_LOAD_ENABLED 490 if ( resolve_symbols( library_handle, &desc, 1 ) ) {
492 return pin_symbols( desc, descriptors, required );
495 if ( resolve_symbols( library_handle, descriptors, required ) )
496 return library_handle;
504 LIBRARY_ASSERT( src,
"The library handle to store must be non-zero" );
507 #if __TBB_DYNAMIC_LOAD_ENABLED 515 #if __TBB_DYNAMIC_LOAD_ENABLED 519 size_t rc = abs_path( library, path, len );
520 if ( 0 < rc && rc <= len ) {
524 UINT prev_mode = SetErrorMode (SEM_FAILCRITICALERRORS);
528 SetErrorMode (prev_mode);
530 if( library_handle ) {
531 if( !resolve_symbols( library_handle, descriptors, required ) ) {
534 library_handle = NULL;
538 return library_handle;
548 init_dynamic_link_data();
554 library_handle = dynamic_load( library, descriptors, required );
557 return weak_symbol_link( descriptors, required );
559 if ( library_handle ) {
560 save_library_handle( library_handle, handle );
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function h
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
void suppress_unused_warning(const T1 &)
Utility template function to prevent "unused" warnings by various compilers.
const char * name
Name of the handler.
#define CLOSE_INTERNAL_NAMESPACE
Association between a handler name and location of pointer to it.
OPEN_INTERNAL_NAMESPACE bool dynamic_link(const char *, const dynamic_link_descriptor *, size_t, dynamic_link_handle *handle, int)
const int DYNAMIC_LINK_WEAK
#define OPEN_INTERNAL_NAMESPACE
const int DYNAMIC_LINK_LOAD
void * dynamic_link_handle
void atomic_do_once(const F &initializer, atomic< do_once_state > &state)
One-time initialization function.
const int DYNAMIC_LINK_GLOBAL
Primary template for atomic.
pointer_to_handler * handler
Pointer to the handler.
void dynamic_unlink_all()
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t size
OPEN_INTERNAL_NAMESPACE typedef void(* pointer_to_handler)()
Type definition for a pointer to a void somefunc(void)
#define LIBRARY_ASSERT(x, y)
void dynamic_unlink(dynamic_link_handle)
void const char const char int ITT_FORMAT __itt_group_sync x void const char * name