Rev 4874 | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
4349 | Serge | 1 | /* |
2 | * COmmon routine to call call registered atexit-like routines. |
||
3 | */ |
||
4 | |||
5 | |||
6 | #include |
||
7 | #include |
||
8 | #include |
||
9 | #include "atexit.h" |
||
10 | |||
11 | /* Make this a weak reference to avoid pulling in free. */ |
||
12 | void free(void *) _ATTRIBUTE((__weak__)); |
||
13 | |||
4921 | Serge | 14 | __LOCK_INIT_RECURSIVE(, __atexit_lock); |
15 | |||
16 | #ifdef _REENT_GLOBAL_ATEXIT |
||
17 | struct _atexit *_global_atexit = _NULL; |
||
4349 | Serge | 18 | #endif |
19 | |||
20 | #ifdef _WANT_REGISTER_FINI |
||
21 | |||
22 | /* If "__libc_fini" is defined, finalizers (either |
||
23 | "__libc_fini_array", or "_fini", as appropriate) will be run after |
||
24 | all user-specified atexit handlers. For example, you can define |
||
25 | "__libc_fini" to "_fini" in your linker script if you want the C |
||
26 | library, rather than startup code, to register finalizers. If you |
||
27 | do that, then your startup code need not contain references to |
||
28 | "atexit" or "exit". As a result, only applications that reference |
||
29 | "exit" explicitly will pull in finalization code. |
||
30 | |||
31 | The choice of whether to register finalizers from libc or from |
||
32 | startup code is deferred to link-time, rather than being a |
||
33 | configure-time option, so that the same C library binary can be |
||
34 | used with multiple BSPs, some of which register finalizers from |
||
35 | startup code, while others defer to the C library. */ |
||
36 | extern char __libc_fini __attribute__((weak)); |
||
37 | |||
38 | /* Register the application finalization function with atexit. These |
||
39 | finalizers should run last. Therefore, we want to call atexit as |
||
40 | soon as possible. */ |
||
41 | static void |
||
42 | register_fini(void) __attribute__((constructor (0))); |
||
43 | |||
44 | static void |
||
45 | register_fini(void) |
||
46 | { |
||
47 | if (&__libc_fini) { |
||
48 | #ifdef HAVE_INITFINI_ARRAY |
||
49 | extern void __libc_fini_array (void); |
||
50 | atexit (__libc_fini_array); |
||
51 | #else |
||
52 | extern void _fini (void); |
||
53 | atexit (_fini); |
||
54 | #endif |
||
55 | } |
||
56 | } |
||
57 | |||
58 | #endif /* _WANT_REGISTER_FINI */ |
||
59 | |||
60 | /* |
||
61 | * Call registered exit handlers. If D is null then all handlers are called, |
||
62 | * otherwise only the handlers from that DSO are called. |
||
63 | */ |
||
64 | |||
65 | void |
||
66 | _DEFUN (__call_exitprocs, (code, d), |
||
67 | int code _AND _PTR d) |
||
68 | { |
||
69 | register struct _atexit *p; |
||
70 | struct _atexit **lastp; |
||
71 | register struct _on_exit_args * args; |
||
72 | register int n; |
||
73 | int i; |
||
74 | void (*fn) (void); |
||
75 | |||
76 | |||
77 | #ifndef __SINGLE_THREAD__ |
||
78 | __lock_acquire_recursive(__atexit_lock); |
||
79 | #endif |
||
80 | |||
81 | restart: |
||
82 | |||
4921 | Serge | 83 | p = _GLOBAL_ATEXIT; |
84 | lastp = &_GLOBAL_ATEXIT; |
||
4349 | Serge | 85 | while (p) |
86 | { |
||
87 | #ifdef _REENT_SMALL |
||
88 | args = p->_on_exit_args_ptr; |
||
89 | #else |
||
90 | args = &p->_on_exit_args; |
||
91 | #endif |
||
92 | for (n = p->_ind - 1; n >= 0; n--) |
||
93 | { |
||
94 | int ind; |
||
95 | |||
96 | i = 1 << n; |
||
97 | |||
98 | /* Skip functions not from this dso. */ |
||
99 | if (d && (!args || args->_dso_handle[n] != d)) |
||
100 | continue; |
||
101 | |||
102 | /* Remove the function now to protect against the |
||
103 | function calling exit recursively. */ |
||
104 | fn = p->_fns[n]; |
||
105 | if (n == p->_ind - 1) |
||
106 | p->_ind--; |
||
107 | else |
||
108 | p->_fns[n] = NULL; |
||
109 | |||
110 | /* Skip functions that have already been called. */ |
||
111 | if (!fn) |
||
112 | continue; |
||
113 | |||
114 | ind = p->_ind; |
||
115 | |||
116 | /* Call the function. */ |
||
117 | if (!args || (args->_fntypes & i) == 0) |
||
118 | fn (); |
||
119 | else if ((args->_is_cxa & i) == 0) |
||
120 | (*((void (*)(int, _PTR)) fn))(code, args->_fnargs[n]); |
||
121 | else |
||
122 | (*((void (*)(_PTR)) fn))(args->_fnargs[n]); |
||
123 | |||
124 | /* The function we called call atexit and registered another |
||
125 | function (or functions). Call these new functions before |
||
126 | continuing with the already registered functions. */ |
||
127 | if (ind != p->_ind || *lastp != p) |
||
128 | goto restart; |
||
129 | } |
||
130 | |||
131 | #ifndef _ATEXIT_DYNAMIC_ALLOC |
||
132 | break; |
||
133 | #else |
||
134 | /* Don't dynamically free the atexit array if free is not |
||
135 | available. */ |
||
136 | if (!free) |
||
137 | break; |
||
138 | |||
139 | /* Move to the next block. Free empty blocks except the last one, |
||
140 | which is part of _GLOBAL_REENT. */ |
||
141 | if (p->_ind == 0 && p->_next) |
||
142 | { |
||
143 | /* Remove empty block from the list. */ |
||
144 | *lastp = p->_next; |
||
145 | #ifdef _REENT_SMALL |
||
146 | if (args) |
||
147 | free (args); |
||
148 | #endif |
||
149 | free (p); |
||
150 | p = *lastp; |
||
151 | } |
||
152 | else |
||
153 | { |
||
154 | lastp = &p->_next; |
||
155 | p = p->_next; |
||
156 | } |
||
157 | #endif |
||
158 | } |
||
159 | #ifndef __SINGLE_THREAD__ |
||
160 | __lock_release_recursive(__atexit_lock); |
||
161 | #endif |
||
162 | |||
163 | }><> |