Automatycznie wykonywane funkcje podczas ładowania bibliotek współdzielonych

Możesz zdefiniować funkcję on-load dla biblioteki Linuksa używając mechanizmu .init. Jest to to samo, co określenie punktu wejścia w czasie ładowania dla programu binarnego (np. użycie czegoś innego niż main jako punktu wejścia dla programu).

Podczas linkowania używając ld bezpośrednio używasz:

-init <function name>

Lub jeśli używasz cc/gcc do linkowania, używasz:

-Wl,-init,<function name>

To jest na najprostszym poziomie.

Edit W przypadku destruktorów / finalizatorów używa się .fini mechanizm. Działa to w taki sam sposób jak opcja init, a Ty używasz:

-fini <function name>

Podczas wywoływania ld. Dostępność jest ograniczona do opcji -init na platformie Mac OSX.

Powinieneś także móc używać składni __attribute__((constructor)) dla gcc:

static void con() __attribute__((constructor));

void con() {
    printf("I'm a constructor\n");
}

Który jest prawdopodobnie bardziej przenośny sposób, a nie wkręcanie w opcje linkera. Wszystkie konstruktory powinny być wywoływane w czasie ładowania, ale nie zależą od kolejności ich inicjalizacji, co prowadzi do insanity i nieodwracalne błędy, które kosztują czas i wysiłek, aby debugować.

Edit 2 użycie semantycznego __attribute__((constructor))/__attribute__((destructor)) jest najbardziej pożądanym mechanizmem dla języka programowania C / C++.

Dla D języka programowania powinieneś naprawdę użyć konstruktora/destruktora modułu statycznego:

static this() {
    printf("static this for mymodule\n");
}
static ~this() {
    printf("static ~this for mymodule\n");
}

Lub konstruktor klasy statycznej:

class Foo {
    static this() {
        printf("static this for Foo\n");
    }
}

Edytuj 3 będziesz musiał połączyć się w .o, który eksportuje procedury konstruktora/destruktora, które pozwolą na użycie statycznych inicjalizatorów. Jak wszystko, co powinno zrobić, to wywołać Runtime.initialize () wywołuje wszystkie statyczne konstruktory/destruktory w kodzie D.

Kod Stub d dla inicjalizatora (w pliku o nazwie myshared.d):

import core.runtime;

extern (C) {
    void attach();
    void detach();
}

export void attach() {
    Runtime.initialize();
}

export void detach() {
    Runtime.terminate();
}

Create the .o dla tego stub:

 dmd -m32 -c myshared.d

Sprawdź nazwy funkcji dołączania/odłączania:

nm myshared.o

Pokazuje (między innymi):

0000001c S _D8myshared6attachFZv
00000034 S _D8myshared6detachFZv

Próbka .kod c do wywołania tego (tzw. export.c w tym przypadku), odwołujemy się do nazw wyeksportowanych procedur z pliku my shared.o:

extern void D8myshared6attachFZv(void);
extern void D8myshared6detachFZv(void);

void __attach(void) __attribute__((constructor));
void __detach(void) __attribute__((destructor));

void __attach(void)
{
    D8myshared6attachFZv();
}

void __detach(void)
{
    D8myshared6detachFZv();
}

Zauważ, że odniesienia extern void muszą używać zniekształconej nazwy eksportowanej funkcji. Muszą być zgodne lub kod nie będzie łączony.

Skompiluj kod C używając:

gcc -m32 -c export.c

Link the .c. O i w .pliki d. O razem używając:

cc -o libmyshared.dylib -m32 -shared myshared.o export.o -lphobos2

Zakładając, że biblioteka phobos2 znajduje się w standardowej ścieżce wyszukiwania linkera. Smatteringi opcji -m32 dla kompilatora i linkera są spowodowane tym, że wersja kompilatora D, którą zbudowałem lokalnie, obsługiwała tylko 32bit.

To daje .dylib, z którym można się połączyć. Wydaje się, że działa w oparciu o ograniczone testy, które wykonałem. Wygląda na to, że wsparcie dla współdzielonych obiektów / dynamicznych bibliotek jest bardzo ograniczone, więc jest dobry szansa, że będzie kolejna przeszkoda do pokonania.