126 lines
4.4 KiB
C
126 lines
4.4 KiB
C
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
|
|
│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│
|
|
╞══════════════════════════════════════════════════════════════════════════════╡
|
|
│ Copyright 2020 Justine Alexandra Roberts Tunney │
|
|
│ │
|
|
│ This program is free software; you can redistribute it and/or modify │
|
|
│ it under the terms of the GNU General Public License as published by │
|
|
│ the Free Software Foundation; version 2 of the License. │
|
|
│ │
|
|
│ This program is distributed in the hope that it will be useful, but │
|
|
│ WITHOUT ANY WARRANTY; without even the implied warranty of │
|
|
│ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU │
|
|
│ General Public License for more details. │
|
|
│ │
|
|
│ You should have received a copy of the GNU General Public License │
|
|
│ along with this program; if not, write to the Free Software │
|
|
│ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA │
|
|
│ 02110-1301 USA │
|
|
╚─────────────────────────────────────────────────────────────────────────────*/
|
|
#include "libc/assert.h"
|
|
#include "libc/bits/weaken.h"
|
|
#include "libc/macros.h"
|
|
#include "libc/mem/mem.h"
|
|
#include "libc/nexgen32e/bsf.h"
|
|
#include "libc/nexgen32e/bsr.h"
|
|
#include "libc/runtime/runtime.h"
|
|
#include "libc/sysv/errfuns.h"
|
|
|
|
static struct CxaAtexitBlocks {
|
|
struct CxaAtexitBlock {
|
|
unsigned mask;
|
|
struct CxaAtexitBlock *next;
|
|
struct CxaAtexit {
|
|
void *fp;
|
|
void *arg;
|
|
void *pred;
|
|
} p[ATEXIT_MAX];
|
|
} * p, root;
|
|
} __cxa_blocks;
|
|
|
|
/**
|
|
* Adds global destructor.
|
|
*
|
|
* Destructors are called in reverse order. They won't be called if the
|
|
* program aborts or _exit() is called. Invocations of this function are
|
|
* usually generated by the C++ compiler. Behavior is limitless if some
|
|
* other module has linked calloc().
|
|
*
|
|
* @param fp is void(*)(T)
|
|
* @param arg is passed to callback
|
|
* @param pred can be non-null for things like dso modules
|
|
* @return 0 on success or nonzero w/ errno
|
|
* @note folks have forked libc in past just to unbloat atexit()
|
|
*/
|
|
int __cxa_atexit(void *fp, void *arg, void *pred) {
|
|
unsigned i;
|
|
struct CxaAtexitBlock *b, *b2;
|
|
b = __cxa_blocks.p;
|
|
if (!b) b = __cxa_blocks.p = &__cxa_blocks.root;
|
|
if (!~b->mask) {
|
|
if (weaken(calloc) &&
|
|
(b2 = weaken(calloc)(1, sizeof(struct CxaAtexitBlock)))) {
|
|
b2->next = b;
|
|
__cxa_blocks.p = b = b2;
|
|
} else {
|
|
return enomem();
|
|
}
|
|
}
|
|
i = bsr(~b->mask);
|
|
assert(i < ARRAYLEN(b->p));
|
|
b->mask |= 1u << i;
|
|
b->p[i].fp = fp;
|
|
b->p[i].arg = arg;
|
|
b->p[i].pred = pred;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Triggers global destructors.
|
|
*
|
|
* They're called in LIFO order. If a destructor adds more destructors,
|
|
* then those destructors will be called immediately following, before
|
|
* iteration continues.
|
|
*
|
|
* @param pred can be null to match all
|
|
*/
|
|
void __cxa_finalize(void *pred) {
|
|
unsigned i;
|
|
unsigned long mask;
|
|
struct CxaAtexitBlock *b, *b2;
|
|
StartOver:
|
|
if ((b = __cxa_blocks.p)) {
|
|
for (;;) {
|
|
mask = b->mask;
|
|
while (mask) {
|
|
i = bsf(mask);
|
|
mask &= ~(1u << i);
|
|
if (!pred || pred == b->p[i].pred) {
|
|
b->mask &= ~(1u << i);
|
|
if (b->p[i].fp) {
|
|
((void (*)(void *))b->p[i].fp)(b->p[i].arg);
|
|
goto StartOver;
|
|
}
|
|
}
|
|
}
|
|
if (!pred) {
|
|
b2 = b->next;
|
|
if (b2) {
|
|
assert(b != &__cxa_blocks.root);
|
|
if (weaken(free)) {
|
|
weaken(free)(b);
|
|
}
|
|
}
|
|
__cxa_blocks.p = b2;
|
|
goto StartOver;
|
|
} else {
|
|
if (b->next) {
|
|
b = b->next;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|