qt

35791 | #include <dlfcn.h>
35792 | static void *unixDlOpen(sqlite3_vfs *NotUsed, const char *zFilename){
35793 |   UNUSED_PARAMETER(NotUsed);
35794 |   return dlopen(zFilename, RTLD_NOW | RTLD_GLOBAL);
35795 | }
35796 | 

486 |     int max_display_attributes;
487 |     const char *str_vendor;
488 | 
489 |     void *handle;			/* dlopen handle */
490 | 
491 |     /**

114 |   X(snd_mixer_selem_set_capture_volume_all) \
115 |   X(snd_mixer_selem_get_capture_volume) \
116 |   X(snd_mixer_selem_get_capture_volume_range) \
117 |   X(snd_dlopen) \
118 |   X(snd_dlclose) \
119 |   X(snd_config) \

131 | 
132 | 
133 | static void *ll_load (lua_State *L, const char *path, int seeglb) {
134 |   void *lib = dlopen(path, RTLD_NOW | (seeglb ? RTLD_GLOBAL : RTLD_LOCAL));
135 |   if (lib == NULL) lua_pushstring(L, dlerror());
136 |   return lib;

493 |     typedef unsigned long getauxval_func_t(unsigned long);
494 | 
495 |     dlerror();
496 |     void* libc_handle = dlopen("libc.so", RTLD_NOW);
497 |     if (!libc_handle) {
498 |         D("Could not dlopen() C library: %s\n", dlerror());
499 |         return 0;
500 |     }

44 | util_dl_open(const char *filename)
45 | {
46 | #if defined(PIPE_OS_UNIX)
47 |    return (struct util_dl_library *)dlopen(filename, RTLD_LAZY | RTLD_GLOBAL);
48 | #elif defined(PIPE_OS_WINDOWS)
49 |    return (struct util_dl_library *)LoadLibraryA(filename);

46 | static struct util_dl_library *egl_st_gl_lib;
47 | 
48 | static EGLBoolean
49 | dlopen_gl_lib_cb(const char *dir, size_t len, void *callback_data)
50 | {
51 |    const char *name = (const char *) callback_data;
76 |    struct st_api *(*create_api)(void);
77 |    struct st_api *stapi = NULL;
78 | 
79 |    _eglSearchPathForEach(dlopen_gl_lib_cb, (void *) name);
80 |    if (!egl_st_gl_lib)
81 |       return NULL;

43 |  * Note that 'flags' isn't used at this time.
44 |  */
45 | static inline void *
46 | _mesa_dlopen(const char *libname, int flags)
47 | {
48 | #if defined(__blrts)
49 |    return NULL;
50 | #elif defined(HAVE_DLOPEN)
51 |    flags = RTLD_LAZY | RTLD_GLOBAL; /* Overriding flags at this time */
52 |    return dlopen(libname, flags);
53 | #elif defined(__MINGW32__)
54 |    return LoadLibraryA(libname);

112 |    ctx->Mesa_DXTn = GL_FALSE;
113 | #if USE_EXTERNAL_DXTN_LIB
114 |    if (!dxtlibhandle) {
115 |       dxtlibhandle = _mesa_dlopen(DXTN_LIBNAME, 0);
116 |       if (!dxtlibhandle) {
117 | 	 _mesa_warning(ctx, "couldn't open " DXTN_LIBNAME ", software DXTn "

114 | static void *
115 | open_library(const char *filename)
116 | {
117 |    return dlopen(filename, RTLD_LAZY);
118 | }
119 | 
146 | 
147 |    assert(driverPath);
148 | 
149 |    _eglLog(_EGL_DEBUG, "dlopen(%s)", driverPath);
150 |    lib = open_library(driverPath);
151 | 

389 | #if GLX_USE_TLS
390 |       snprintf(path, sizeof path,
391 | 	       "%.*s/tls/%s_dri.so", len, p, dri2_dpy->driver_name);
392 |       dri2_dpy->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
393 | #endif
394 |       if (dri2_dpy->driver == NULL) {
395 | 	 snprintf(path, sizeof path,
396 | 		  "%.*s/%s_dri.so", len, p, dri2_dpy->driver_name);
397 | 	 dri2_dpy->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
398 | 	 if (dri2_dpy->driver == NULL)
399 | 	    _eglLog(_EGL_DEBUG, "failed to open %s: %s\n", path, dlerror());
407 |       return NULL;
408 |    }
409 | 
410 |    _eglLog(_EGL_DEBUG, "DRI2: dlopen(%s)", path);
411 |    extensions = dlsym(dri2_dpy->driver, __DRI_DRIVER_EXTENSIONS);
412 |    if (extensions == NULL) {
1505 |    void *handle;
1506 | 
1507 |    /* RTLD_GLOBAL to make sure glapi symbols are visible to DRI drivers */
1508 |    handle = dlopen(libname, RTLD_LAZY | RTLD_GLOBAL);
1509 |    if (handle) {
1510 |       dri2_drv->get_proc_address = (_EGLProc (*)(const char *))

1075 |    if (!GLX_drv->glXGetProcAddress)
1076 |       GLX_drv->glXGetProcAddress = dlsym(RTLD_DEFAULT, "glXGetProcAddressARB");
1077 |    if (!GLX_drv->glXGetProcAddress) {
1078 |       handle = dlopen("libGL.so", RTLD_LAZY | RTLD_LOCAL);
1079 |       if (!handle)
1080 |          goto fail;

69 |       else
70 |          snprintf(path, sizeof path, "%s", name);
71 | 
72 |       module = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
73 |       if (!module) {
74 |          fprintf(stderr,

191 | #if GLX_USE_TLS
192 |       snprintf(path, sizeof path,
193 |                "%.*s/tls/%s_dri.so", len, p, dri->base.driver_name);
194 |       dri->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
195 | #endif
196 |       if (dri->driver == NULL) {
197 |          snprintf(path, sizeof path,
198 |                   "%.*s/%s_dri.so", len, p, dri->base.driver_name);
199 |          dri->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
200 |          if (dri->driver == NULL)
201 |             fprintf(stderr, "failed to open %s: %s\n", path, dlerror());

133 |    int len;
134 | 
135 |    /* Attempt to make sure libGL symbols will be visible to the driver */
136 |    glhandle = dlopen("libGL.so.1", RTLD_NOW | RTLD_GLOBAL);
137 | 
138 |    libPaths = NULL;
161 |       snprintf(realDriverName, sizeof realDriverName,
162 |                "%.*s/tls/%s_dri.so", len, p, driverName);
163 |       InfoMessageF("OpenDriver: trying %s\n", realDriverName);
164 |       handle = dlopen(realDriverName, RTLD_NOW | RTLD_GLOBAL);
165 | #endif
166 | 
168 |          snprintf(realDriverName, sizeof realDriverName,
169 |                   "%.*s/%s_dri.so", len, p, driverName);
170 |          InfoMessageF("OpenDriver: trying %s\n", realDriverName);
171 |          handle = dlopen(realDriverName, RTLD_NOW | RTLD_GLOBAL);
172 |       }
173 | 
174 |       if (handle != NULL)
175 |          break;
176 |       else
177 |          ErrorMessageF("dlopen %s failed (%s)\n", realDriverName, dlerror());
178 |    }
179 | 

74 |    }
75 | 
76 |    (void) dlerror();            /*drain dlerror */
77 |    h = dlopen(opengl_framework_path, RTLD_NOW);
78 | 
79 |    if (NULL == h) {
80 |       fprintf(stderr, "error: unable to dlopen %s : %s\n",
81 |               opengl_framework_path, dlerror());
82 |       abort();

353 |     void *ret = NULL;
354 | 
355 |     if (path) {
356 |         ret = dlopen(path, RTLD_LOCAL|RTLD_NOW);
357 |         av_free(path);
358 |     }
412 | 
413 |     if (s->dl_name[0] == '/' || s->dl_name[0] == '.') {
414 |         // argument is a path
415 |         s->dl_handle = dlopen(s->dl_name, RTLD_LOCAL|RTLD_NOW);
416 |     } else {
417 |         // argument is a shared object name

97 |                                 const char *libname2)
98 | {
99 |     if (libname2) {
100 |         s->lib2 = dlopen(libname2, RTLD_NOW | RTLD_GLOBAL);
101 |         if (!s->lib2) {
102 |             av_log(logctx, AV_LOG_WARNING, "%s not found\n", libname);
110 |             return AVERROR_ENCODER_NOT_FOUND;
111 |         }
112 |     }
113 |     s->lib = dlopen(libname, RTLD_NOW | RTLD_GLOBAL);
114 |     if (!s->lib) {
115 |         av_log(logctx, AV_LOG_WARNING, "%s not found\n", libname);

56 | 
57 | #define LOAD_LIBRARY(l, path)                   \
58 |     do {                                        \
59 |         if (!((l) = dlopen(path, RTLD_LAZY))) { \
60 |             av_log(avctx, AV_LOG_ERROR,         \
61 |                    "Cannot load %s\n",          \

216 | static void *
217 | xmlModulePlatformOpen(const char *name)
218 | {
219 |     return dlopen(name, RTLD_GLOBAL | RTLD_NOW);
220 | }
221 | 

6045 | #include <dlfcn.h>
6046 | static void *unixDlOpen(sqlite3_vfs *NotUsed, const char *zFilename){
6047 |   UNUSED_PARAMETER(NotUsed);
6048 |   return dlopen(zFilename, RTLD_NOW | RTLD_GLOBAL);
6049 | }
6050 | 

5996 | #include <dlfcn.h>
5997 | static void *unixDlOpen(sqlite3_vfs *NotUsed, const char *zFilename){
5998 |   UNUSED_PARAMETER(NotUsed);
5999 |   return dlopen(zFilename, RTLD_NOW | RTLD_GLOBAL);
6000 | }
6001 | 

33121 | #include <dlfcn.h>
33122 | static void *unixDlOpen(sqlite3_vfs *NotUsed, const char *zFilename){
33123 |   UNUSED_PARAMETER(NotUsed);
33124 |   return dlopen(zFilename, RTLD_NOW | RTLD_GLOBAL);
33125 | }
33126 | 

1377 | 
1378 |   ACTF("Loading postprocessor from '%s'...", fn);
1379 | 
1380 |   dh = dlopen(fn, RTLD_NOW);
1381 |   if (!dh) FATAL("%s", dlerror());
1382 | 

87 |      * dlopen returns. Since RTLD_GLOBAL is not or'd in with
88 |      * RTLD_NOW the external symbols will not be global
89 |      */
90 |     handle = dlopen(path, RTLD_NOW);
91 |     if (handle == NULL) {
92 |         char const *err_str = dlerror();