-#include <stddef.h>
#include <stdlib.h>
#include <stdint.h>
-#include <limits.h>
#include "libc.h"
+#include "lock.h"
+#include "fork_impl.h"
+
+#define malloc __libc_malloc
+#define calloc __libc_calloc
+#define realloc undef
+#define free undef
/* Ensure that at least 32 atexit handlers can be registered without malloc */
#define COUNT 32
void *a[COUNT];
} builtin, *head;
-static int lock;
+static int slot;
+static volatile int lock[1];
+volatile int *const __atexit_lockptr = lock;
void __funcs_on_exit()
{
- int i;
void (*func)(void *), *arg;
- LOCK(&lock);
- for (; head; head=head->next) {
- for (i=COUNT-1; i>=0 && !head->f[i]; i--);
- if (i<0) continue;
- func = head->f[i];
- arg = head->a[i];
- head->f[i] = 0;
- UNLOCK(&lock);
+ LOCK(lock);
+ for (; head; head=head->next, slot=COUNT) while(slot-->0) {
+ func = head->f[slot];
+ arg = head->a[slot];
+ UNLOCK(lock);
func(arg);
- LOCK(&lock);
+ LOCK(lock);
}
}
-int __cxa_atexit(void (*func)(void *), void *arg, void *dso)
+void __cxa_finalize(void *dso)
{
- int i;
+}
- LOCK(&lock);
+int __cxa_atexit(void (*func)(void *), void *arg, void *dso)
+{
+ LOCK(lock);
/* Defer initialization of head so it can be in BSS */
if (!head) head = &builtin;
/* If the current function list is full, add a new one */
- if (head->f[COUNT-1]) {
+ if (slot==COUNT) {
struct fl *new_fl = calloc(sizeof(struct fl), 1);
if (!new_fl) {
- UNLOCK(&lock);
+ UNLOCK(lock);
return -1;
}
new_fl->next = head;
head = new_fl;
+ slot = 0;
}
/* Append function to the list. */
- for (i=0; i<COUNT && head->f[i]; i++);
- head->f[i] = func;
- head->a[i] = arg;
+ head->f[slot] = func;
+ head->a[slot] = arg;
+ slot++;
- UNLOCK(&lock);
+ UNLOCK(lock);
return 0;
}