The Tor Browser / file comparison
comparison: build/stlport/src/cxa.c
build/stlport/src/cxa.c
- changeset 0
- 6474c204b198
equal
deleted
inserted
replaced
| -1:000000000000 | 0:224ca1f04d24 |
|---|---|
| 1 #include "stlport_prefix.h" | |
| 2 | |
| 3 #if defined(__unix) && defined(__GNUC__) | |
| 4 | |
| 5 #ifdef __FreeBSD__ | |
| 6 # include <osreldate.h> | |
| 7 #endif | |
| 8 | |
| 9 #if (defined(__FreeBSD__) && (__FreeBSD_version < 503001)) || defined(__sun) || defined (__hpux) | |
| 10 /* Note: __cxa_finalize and __cxa_atexit present in libc in FreeBSD 5.3 */ | |
| 11 | |
| 12 #include <stdlib.h> | |
| 13 #include <stdio.h> | |
| 14 #include <pthread.h> | |
| 15 | |
| 16 /* __asm__ (".symver " "__cxa_finalize" "," "__cxa_finalize" "@" "STLPORT_5_0_0"); */ | |
| 17 /* __asm__ (".symver " "__cxa_finalize" "," "__cxa_finalize" "@@" "STLPORT_5_0_0"); */ | |
| 18 | |
| 19 /* Not atomic! */ | |
| 20 /* But we can use static mutexes here: I hope that performance issue isn't very | |
| 21 significant on unloading (for only few calls, ~10) - ptr */ | |
| 22 | |
| 23 /* | |
| 24 #define atomic_compare_and_exchange_bool_acq(mem, newval, oldval) \ | |
| 25 ({ __typeof (mem) __gmemp = (mem); \ | |
| 26 __typeof (*mem) __gnewval = (newval); \ | |
| 27 \ | |
| 28 *__gmemp == (oldval) ? (*__gmemp = __gnewval, 0) : 1; }) | |
| 29 */ | |
| 30 | |
| 31 enum { | |
| 32 ef_free, /* `ef_free' MUST be zero! */ | |
| 33 ef_us, | |
| 34 ef_on, | |
| 35 ef_at, | |
| 36 ef_cxa | |
| 37 }; | |
| 38 | |
| 39 struct exit_function | |
| 40 { | |
| 41 /* `flavour' should be of type of the `enum' above but since we need | |
| 42 this element in an atomic operation we have to use `long int'. */ | |
| 43 long int flavor; | |
| 44 union { | |
| 45 void (*at)(void); | |
| 46 struct { | |
| 47 void (*fn)(int status, void *arg); | |
| 48 void *arg; | |
| 49 } on; | |
| 50 struct { | |
| 51 void (*fn)(void *arg, int status); | |
| 52 void *arg; | |
| 53 void *dso_handle; | |
| 54 } cxa; | |
| 55 } func; | |
| 56 }; | |
| 57 | |
| 58 struct exit_function_list | |
| 59 { | |
| 60 struct exit_function_list *next; | |
| 61 size_t idx; | |
| 62 struct exit_function fns[32]; | |
| 63 }; | |
| 64 | |
| 65 struct exit_function *__new_exitfn (void); | |
| 66 | |
| 67 /* Register a function to be called by exit or when a shared library | |
| 68 is unloaded. This function is only called from code generated by | |
| 69 the C++ compiler. */ | |
| 70 int __cxa_atexit(void (*func)(void *), void *arg, void *d) | |
| 71 { | |
| 72 struct exit_function *new = __new_exitfn (); | |
| 73 | |
| 74 if ( new == NULL ) | |
| 75 return -1; | |
| 76 | |
| 77 new->flavor = ef_cxa; | |
| 78 new->func.cxa.fn = (void (*) (void *, int)) func; | |
| 79 new->func.cxa.arg = arg; | |
| 80 new->func.cxa.dso_handle = d; | |
| 81 return 0; | |
| 82 } | |
| 83 | |
| 84 | |
| 85 /* We change global data, so we need locking. */ | |
| 86 #ifdef __linux__ | |
| 87 static pthread_mutex_t lock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP; | |
| 88 #endif | |
| 89 /* #ifdef __FreeBSD__ */ | |
| 90 #if 0 | |
| 91 static pthread_mutex_t lock = | |
| 92 { PTHREAD_MUTEX_RECURSIVE /* PTHREAD_MUTEX_DEFAULT */, PTHREAD_PRIO_NONE, {NULL,NULL}, | |
| 93 NULL, { NULL }, /* MUTEX_FLAGS_PRIVATE */ 0x1, 0, 0, 0, {NULL, NULL}, | |
| 94 { 0, 0, 0, 0 } }; | |
| 95 #endif | |
| 96 #ifdef __sun | |
| 97 static pthread_mutex_t lock = | |
| 98 {{0, 0, 0, PTHREAD_MUTEX_RECURSIVE, _MUTEX_MAGIC}, {{{0}}}, 0}; | |
| 99 #endif | |
| 100 #ifdef __hpux | |
| 101 static pthread_mutex_t lock = PTHREAD_MUTEX_RECURSIVE_INITIALIZER_NP; | |
| 102 # ifdef __ia64 | |
| 103 void *__dso_handle = (void *) &__dso_handle; | |
| 104 # endif | |
| 105 #endif | |
| 106 | |
| 107 | |
| 108 static struct exit_function_list initial; | |
| 109 struct exit_function_list *__exit_funcs = &initial; | |
| 110 | |
| 111 struct exit_function *__new_exitfn(void) | |
| 112 { | |
| 113 struct exit_function_list *l; | |
| 114 size_t i = 0; | |
| 115 | |
| 116 #ifndef __FreeBSD__ | |
| 117 pthread_mutex_lock( &lock ); | |
| 118 #endif | |
| 119 | |
| 120 for (l = __exit_funcs; l != NULL; l = l->next) { | |
| 121 for (i = 0; i < l->idx; ++i) | |
| 122 if (l->fns[i].flavor == ef_free) | |
| 123 break; | |
| 124 if ( i < l->idx ) | |
| 125 break; | |
| 126 | |
| 127 if (l->idx < sizeof (l->fns) / sizeof (l->fns[0])) { | |
| 128 i = l->idx++; | |
| 129 break; | |
| 130 } | |
| 131 } | |
| 132 | |
| 133 if (l == NULL) { | |
| 134 l = (struct exit_function_list *)malloc( sizeof(struct exit_function_list) ); | |
| 135 if (l != NULL) { | |
| 136 l->next = __exit_funcs; | |
| 137 __exit_funcs = l; | |
| 138 | |
| 139 l->idx = 1; | |
| 140 i = 0; | |
| 141 } | |
| 142 } | |
| 143 | |
| 144 /* Mark entry as used, but we don't know the flavor now. */ | |
| 145 if ( l != NULL ) | |
| 146 l->fns[i].flavor = ef_us; | |
| 147 | |
| 148 #ifndef __FreeBSD__ | |
| 149 pthread_mutex_unlock( &lock ); | |
| 150 #endif | |
| 151 | |
| 152 return l == NULL ? NULL : &l->fns[i]; | |
| 153 } | |
| 154 | |
| 155 /* If D is non-NULL, call all functions registered with `__cxa_atexit' | |
| 156 with the same dso handle. Otherwise, if D is NULL, call all of the | |
| 157 registered handlers. */ | |
| 158 | |
| 159 /* | |
| 160 * Note, that original __cxa_finalize don't use lock, but use __exit_funcs | |
| 161 * i.e. global data. | |
| 162 */ | |
| 163 void __cxa_finalize(void *d) | |
| 164 { | |
| 165 struct exit_function_list *funcs; | |
| 166 | |
| 167 #ifndef __FreeBSD__ | |
| 168 pthread_mutex_lock( &lock ); | |
| 169 #endif | |
| 170 | |
| 171 for (funcs = __exit_funcs; funcs; funcs = funcs->next) { | |
| 172 struct exit_function *f; | |
| 173 | |
| 174 for (f = &funcs->fns[funcs->idx - 1]; f >= &funcs->fns[0]; --f) { | |
| 175 if ( (d == NULL || d == f->func.cxa.dso_handle) && (f->flavor == ef_cxa) ) { | |
| 176 f->flavor = ef_free; | |
| 177 (*f->func.cxa.fn) (f->func.cxa.arg, 0); | |
| 178 } | |
| 179 } | |
| 180 } | |
| 181 | |
| 182 /* Remove the registered fork handlers. We do not have to | |
| 183 unregister anything if the program is going to terminate anyway. */ | |
| 184 #ifdef UNREGISTER_ATFORK | |
| 185 if (d != NULL) | |
| 186 UNREGISTER_ATFORK (d); | |
| 187 #endif | |
| 188 #ifndef __FreeBSD__ | |
| 189 pthread_mutex_unlock( &lock ); | |
| 190 #endif | |
| 191 } | |
| 192 | |
| 193 /* __asm__ (".symver " "__cxa_finalize" "," "__cxa_finalize" "@@" "STLPORT_5_0_0"); */ | |
| 194 /* void __cxa_finalize(void *d) __attribute__ ((weak)); */ | |
| 195 | |
| 196 #endif /* OS name */ | |
| 197 #endif /* __unix */ | |
| 198 |
