core.sys.posix.dlfcn source code

1 /**
2  * D header file for POSIX.
3  *
4  * Copyright: Copyright Sean Kelly 2005 - 2009.
5  * License:   $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0).
6  * Authors:   Sean Kelly, Alex Rønne Petersen
7  * Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
8  */
9 
10 /*          Copyright Sean Kelly 2005 - 2009.
11  * Distributed under the Boost Software License, Version 1.0.
12  *    (See accompanying file LICENSE or copy at
13  *          http://www.boost.org/LICENSE_1_0.txt)
14  */
15 module core.sys.posix.dlfcn;
16 
17 import core.sys.posix.config;
18 
19 version (OSX)
20     version = Darwin;
21 else version (iOS)
22     version = Darwin;
23 else version (TVOS)
24     version = Darwin;
25 else version (WatchOS)
26     version = Darwin;
27 
28 version (ARM)     version = ARM_Any;
29 version (AArch64) version = ARM_Any;
30 version (HPPA)    version = HPPA_Any;
31 version (MIPS32)  version = MIPS_Any;
32 version (MIPS64)  version = MIPS_Any;
33 version (PPC)     version = PPC_Any;
34 version (PPC64)   version = PPC_Any;
35 version (RISCV32) version = RISCV_Any;
36 version (RISCV64) version = RISCV_Any;
37 version (S390)    version = IBMZ_Any;
38 version (SPARC)   version = SPARC_Any;
39 version (SPARC64) version = SPARC_Any;
40 version (SystemZ) version = IBMZ_Any;
41 version (X86)     version = X86_Any;
42 version (X86_64)  version = X86_Any;
43 
44 version (Posix):
45 extern (C):
46 nothrow:
47 @nogc:
48 
49 //
50 // XOpen (XSI)
51 //
52 /*
53 RTLD_LAZY
54 RTLD_NOW
55 RTLD_GLOBAL
56 RTLD_LOCAL
57 
58 int   dlclose(void*);
59 char* dlerror();
60 void* dlopen(const scope char*, int);
61 void* dlsym(void*, const scope char*);
62 */
63 
64 version (CRuntime_Glibc)
65 {
66     version (X86_Any)
67     {
68         // http://sourceware.org/git/?p=glibc.git;a=blob;f=bits/dlfcn.h
69         enum RTLD_LAZY      = 0x00001;
70         enum RTLD_NOW       = 0x00002;
71         enum RTLD_BINDING_MASK = 0x3;
72         enum RTLD_NOLOAD    = 0x00004;
73         enum RTLD_DEEPBIND  = 0x00008;
74         enum RTLD_GLOBAL    = 0x00100;
75         enum RTLD_LOCAL     = 0x00000;
76         enum RTLD_NODELETE  = 0x01000;
77     }
78     else version (HPPA_Any)
79     {
80         // http://sourceware.org/git/?p=glibc.git;a=blob;f=ports/sysdeps/hppa/bits/dlfcn.h
81         enum RTLD_LAZY      = 0x0001;
82         enum RTLD_NOW       = 0x0002;
83         enum RTLD_BINDING_MASK = 0x3;
84         enum RTLD_NOLOAD    = 0x00004;
85         enum RTLD_DEEPBIND  = 0x00008;
86         enum RTLD_GLOBAL    = 0x0100;
87         enum RTLD_LOCAL     = 0;
88         enum RTLD_NODELETE  = 0x01000;
89     }
90     else version (MIPS_Any)
91     {
92     // http://sourceware.org/git/?p=glibc.git;a=blob;f=ports/sysdeps/mips/bits/dlfcn.h
93         enum RTLD_LAZY      = 0x0001;
94         enum RTLD_NOW       = 0x0002;
95         enum RTLD_BINDING_MASK = 0x3;
96         enum RTLD_NOLOAD    = 0x00008;
97         enum RTLD_DEEPBIND  = 0x00010;
98         enum RTLD_GLOBAL    = 0x0004;
99         enum RTLD_LOCAL     = 0;
100         enum RTLD_NODELETE  = 0x01000;
101     }
102     else version (PPC_Any)
103     {
104         // http://sourceware.org/git/?p=glibc.git;a=blob;f=bits/dlfcn.h
105         enum RTLD_LAZY      = 0x00001;
106         enum RTLD_NOW       = 0x00002;
107         enum RTLD_BINDING_MASK = 0x3;
108         enum RTLD_NOLOAD    = 0x00004;
109         enum RTLD_DEEPBIND  = 0x00008;
110         enum RTLD_GLOBAL    = 0x00100;
111         enum RTLD_LOCAL     = 0;
112         enum RTLD_NODELETE  = 0x01000;
113     }
114     else version (ARM_Any)
115     {
116         // http://sourceware.org/git/?p=glibc.git;a=blob;f=bits/dlfcn.h
117         enum RTLD_LAZY      = 0x00001;
118         enum RTLD_NOW       = 0x00002;
119         enum RTLD_BINDING_MASK = 0x3;
120         enum RTLD_NOLOAD    = 0x00004;
121         enum RTLD_DEEPBIND  = 0x00008;
122         enum RTLD_GLOBAL    = 0x00100;
123         enum RTLD_LOCAL     = 0;
124         enum RTLD_NODELETE  = 0x01000;
125     }
126     else version (RISCV_Any)
127     {
128         // http://sourceware.org/git/?p=glibc.git;a=blob;f=bits/dlfcn.h
129         enum RTLD_LAZY      = 0x00001;
130         enum RTLD_NOW       = 0x00002;
131         enum RTLD_BINDING_MASK = 0x3;
132         enum RTLD_NOLOAD    = 0x00004;
133         enum RTLD_DEEPBIND  = 0x00008;
134         enum RTLD_GLOBAL    = 0x00100;
135         enum RTLD_LOCAL     = 0;
136         enum RTLD_NODELETE  = 0x01000;
137     }
138     else version (SPARC_Any)
139     {
140         // http://sourceware.org/git/?p=glibc.git;a=blob;f=bits/dlfcn.h
141         enum RTLD_LAZY      = 0x00001;
142         enum RTLD_NOW       = 0x00002;
143         enum RTLD_BINDING_MASK = 0x3;
144         enum RTLD_NOLOAD    = 0x00004;
145         enum RTLD_DEEPBIND  = 0x00008;
146         enum RTLD_GLOBAL    = 0x00100;
147         enum RTLD_LOCAL     = 0;
148         enum RTLD_NODELETE  = 0x01000;
149 
150     }
151     else version (IBMZ_Any)
152     {
153         // http://sourceware.org/git/?p=glibc.git;a=blob;f=bits/dlfcn.h
154         enum RTLD_LAZY      = 0x00001;
155         enum RTLD_NOW       = 0x00002;
156         enum RTLD_BINDING_MASK = 0x3;
157         enum RTLD_NOLOAD    = 0x00004;
158         enum RTLD_DEEPBIND  = 0x00008;
159         enum RTLD_GLOBAL    = 0x00100;
160         enum RTLD_LOCAL     = 0;
161         enum RTLD_NODELETE  = 0x01000;
162     }
163     else
164         static assert(0, "unimplemented");
165 
166     int   dlclose(void*);
167     char* dlerror();
168     void* dlopen(const scope char*, int);
169     void* dlsym(void*, const scope char*);
170     int dladdr(const scope void*, Dl_info*);
171 
172     struct Dl_info
173     {
174         const(char)* dli_fname;
175         void* dli_fbase;
176         const(char)* dli_sname;
177         void* dli_saddr;
178     }
179 }
180 else
181 version (CRuntime_Musl)
182 {
183     enum RTLD_LAZY   = 1;
184     enum RTLD_NOW    = 2;
185     enum RTLD_NOLOAD = 4;
186     enum RTLD_NODELETE = 4096;
187     enum RTLD_GLOBAL = 256;
188     enum RTLD_LOCAL  = 0;
189 
190     enum RTLD_NEXT    = cast(void *)-1;
191     enum RTLD_DEFAULT = cast(void *)0;
192 
193     enum RTLD_DI_LINKMAP = 2;
194 
195     int    dlclose(void *);
196     char  *dlerror();
197     void  *dlopen(const(char) *, int);
198 
199     pragma(mangle, muslRedirTime64Mangle!("dlsym", "__dlsym_time64"))
200     void  *dlsym(void *__restrict, const(char) *__restrict);
201 
202     struct Dl_info
203     {
204         const(char)* dli_fname;
205         void* dli_fbase;
206         const(char)* dli_sname;
207         void* dli_saddr;
208     }
209     int dladdr(const(void) *, Dl_info *);
210     int dlinfo(void *, int, void *);
211 }
212 else version (Darwin)
213 {
214     enum RTLD_LAZY      = 0x00001;
215     enum RTLD_NOW       = 0x00002;
216     enum RTLD_NOLOAD    = 0x10;
217     enum RTLD_NODELETE  = 0x80;
218     enum RTLD_GLOBAL    = 0x00100;
219     enum RTLD_LOCAL     = 0x00000;
220     enum RTLD_FIRST     = 0x100;
221 
222     int   dlclose(void*);
223     char* dlerror();
224     void* dlopen(const scope char*, int);
225     void* dlsym(void*, const scope char*);
226     int   dladdr(scope const void* addr, Dl_info* info);
227 
228     struct Dl_info
229     {
230         const(char)* dli_fname;
231         void*        dli_fbase;
232         const(char)* dli_sname;
233         void*        dli_saddr;
234     }
235 }
236 else version (FreeBSD)
237 {
238     enum RTLD_LAZY      = 1;
239     enum RTLD_NOW       = 2;
240     enum RTLD_MODEMASK  =  0x3;
241     enum RTLD_GLOBAL    = 0x100;
242     enum RTLD_LOCAL     = 0;
243     enum RTLD_TRACE     =  0x200;
244     enum RTLD_NODELETE  =  0x01000;
245     enum RTLD_NOLOAD    =  0x02000;
246 
247     int   dlclose(void*);
248     char* dlerror();
249     void* dlopen(const scope char*, int);
250     void* dlsym(void*, const scope char*);
251     int   dladdr(const(void)* addr, Dl_info* info);
252 
253     struct Dl_info
254     {
255         const(char)* dli_fname;
256         void*        dli_fbase;
257         const(char)* dli_sname;
258         void*        dli_saddr;
259     }
260 }
261 else version (NetBSD)
262 {
263     enum RTLD_LAZY      = 1;
264     enum RTLD_NOW       = 2;
265     enum RTLD_GLOBAL    = 0x100;
266     enum RTLD_LOCAL     = 0x200;
267     enum RTLD_NODELETE  = 0x01000;         /* Do not remove members. */
268     enum RTLD_NOLOAD    = 0x02000;
269 
270     int   dlclose(void*);
271     char* dlerror();
272     void* dlopen(const scope char*, int);
273     void* dlsym(void*, const scope char*);
274     int   dladdr(const(void)* addr, Dl_info* info);
275 
276     struct Dl_info
277     {
278         const(char)* dli_fname;
279         void*        dli_fbase;
280         const(char)* dli_sname;
281         void*        dli_saddr;
282     }
283 }
284 else version (OpenBSD)
285 {
286     enum RTLD_LAZY      = 1;
287     enum RTLD_NOW       = 2;
288     enum RTLD_GLOBAL    = 0x100;
289     enum RTLD_LOCAL     = 0;
290     enum RTLD_TRACE     = 0x200;
291     enum RTLD_NODELETE  = 0x400;
292 
293     int   dlclose(void*);
294     char* dlerror();
295     void* dlopen(const scope char*, int);
296     void* dlsym(void*, const scope char*);
297     int   dladdr(const(void)* addr, Dl_info* info);
298 
299     struct Dl_info
300     {
301         const(char)* dli_fname;
302         void*        dli_fbase;
303         const(char)* dli_sname;
304         void*        dli_saddr;
305     }
306 }
307 else version (DragonFlyBSD)
308 {
309     enum RTLD_LAZY      = 1;
310     enum RTLD_NOW       = 2;
311     enum RTLD_MODEMASK  =  0x3;
312     enum RTLD_GLOBAL    = 0x100;
313     enum RTLD_LOCAL     = 0;
314     enum RTLD_TRACE     =  0x200;
315     enum RTLD_NODELETE  =  0x01000;
316     enum RTLD_NOLOAD    =  0x02000;
317 
318     int   dlclose(void*);
319     char* dlerror();
320     void* dlopen(const scope char*, int);
321     void* dlsym(void*, const scope char*);
322     int   dladdr(const(void)* addr, Dl_info* info);
323 
324     struct Dl_info
325     {
326         const(char)* dli_fname;
327         void*        dli_fbase;
328         const(char)* dli_sname;
329         void*        dli_saddr;
330     }
331 }
332 else version (Solaris)
333 {
334     enum RTLD_LAZY      = 1;
335     enum RTLD_NOW       = 2;
336     enum RTLD_NOLOAD    = 0x00004;
337     enum RTLD_DEEPBIND  = 0x00008;
338     enum RTLD_GLOBAL    = 0x100;
339     enum RTLD_LOCAL     = 0;
340     enum RTLD_PARENT    = 0x00200;
341     enum RTLD_GROUP     = 0x00400;
342     enum RTLD_WORLD     = 0x00800;
343     enum RTLD_NODELETE  = 0x01000;
344     enum RTLD_FIRST     = 0x02000;
345     enum RTLD_CONFGEN   = 0x10000;
346 
347     int   dlclose(void*);
348     char* dlerror();
349     void* dlopen(const scope char*, int);
350     void* dlsym(void*, const scope char*);
351     int   dladdr(const(void)* addr, Dl_info* info);
352 
353     struct Dl_info
354     {
355         const(char)* dli_fname;
356         void*        dli_fbase;
357         const(char)* dli_sname;
358         void*        dli_saddr;
359     }
360 }
361 else version (CRuntime_Bionic)
362 {
363     enum
364     {
365         RTLD_NOW    = 0,
366         RTLD_LAZY   = 1,
367         RTLD_LOCAL  = 0,
368         RTLD_GLOBAL = 2
369     }
370 
371     int          dladdr(const scope void*, Dl_info*);
372     int          dlclose(void*);
373     const(char)* dlerror();
374     void*        dlopen(const scope char*, int);
375     void*        dlsym(void*, const scope char*);
376 
377     struct Dl_info
378     {
379         const(char)* dli_fname;
380         void*        dli_fbase;
381         const(char)* dli_sname;
382         void*        dli_saddr;
383     }
384 }
385 else version (CRuntime_Musl)
386 {
387     enum {
388         RTLD_LAZY     = 1,
389         RTLD_NOW      = 2,
390         RTLD_NOLOAD   = 4,
391         RTLD_NODELETE = 4096,
392         RTLD_GLOBAL   = 256,
393         RTLD_LOCAL    = 0,
394     }
395     int          dlclose(void*);
396     const(char)* dlerror();
397     void*        dlopen(const scope char*, int);
398     void*        dlsym(void*, const scope char*);
399 
400     int dladdr(scope const void *addr, Dl_info *info);
401     struct Dl_info
402     {
403         const(char)* dli_fname;
404         void*        dli_fbase;
405         const(char)* dli_sname;
406         void*        dli_saddr;
407     }
408 }
409 else version (CRuntime_UClibc)
410 {
411     version (X86_Any)
412     {
413         enum RTLD_LAZY              = 0x0001;
414         enum RTLD_NOW               = 0x0002;
415         enum RTLD_BINDING_MASK      = 0x3;
416         enum RTLD_NOLOAD            = 0x00004;
417         enum RTLD_GLOBAL            = 0x00100;
418         enum RTLD_LOCAL             = 0;
419         enum RTLD_NODELETE          = 0x01000;
420     }
421     else version (MIPS_Any)
422     {
423         enum RTLD_LAZY              = 0x0001;
424         enum RTLD_NOW               = 0x0002;
425         enum RTLD_BINDING_MASK      = 0x3;
426         enum RTLD_NOLOAD            = 0x00008;
427         enum RTLD_GLOBAL            = 0x0004;
428         enum RTLD_LOCAL             = 0;
429         enum RTLD_NODELETE          = 0x01000;
430     }
431     else version (ARM)
432     {
433         enum RTLD_LAZY              = 0x0001;
434         enum RTLD_NOW               = 0x0002;
435         enum RTLD_BINDING_MASK      = 0x3;
436         enum RTLD_NOLOAD            = 0x00004;
437         enum RTLD_GLOBAL            = 0x00100;
438         enum RTLD_LOCAL             = 0;
439         enum RTLD_NODELETE          = 0x01000;
440     }
441     else
442         static assert(0, "unimplemented");
443 
444     int   dlclose(void*);
445     char* dlerror();
446     void* dlopen(const scope char*, int);
447     void* dlsym(void*, const scope char*);
448     int dladdr(const scope void*, Dl_info*);
449 
450     struct Dl_info
451     {
452         const(char)* dli_fname;
453         void* dli_fbase;
454         const(char)* dli_sname;
455         void* dli_saddr;
456     }
457 }