Comment fonctionne exactement __attribute__((constructeur)) de travail?

.init/.fini n'est pas obsolète. C'est toujours une partie de l'ELFE de la norme et j'oserais dire que ce sera pour toujours. Code .init/.fini est géré par le chargeur/runtime-linker lorsque le code est chargé/déchargé. I. e. sur chaque ELFE de la charge (par exemple une bibliothèque partagée) du code de .init sera exécuté. Il est encore possible d'utiliser ce mécanisme pour atteindre environ la même chose qu'avec les __attribute__((constructor))/((destructor)). C'est de la vieille école, mais il a quelques avantages.

.ctors/.dtors mécanisme par exemple besoin d'un soutien par le système-rtl/chargeur/linker script. C'est loin d'être certain d'être disponible sur tous les systèmes, par exemple profondément les systèmes embarqués où le code s'exécute sur le métal nu. I. e. même si __attribute__((constructor))/((destructor)) est pris en charge par GCC, il n'est pas certain qu'il va exécuter en tant qu'il est à l'éditeur de liens à l'organiser et à le chargeur (ou, dans certains cas, du code de démarrage) pour l'exécuter. Pour utiliser .init/.fini au lieu de cela, le plus simple est d'utiliser l'éditeur de liens indicateurs: -init & -fini (c'est à dire à partir de GCC en ligne de commande, la syntaxe serait -Wl -init my_init -fini my_fini).

Sur le système de soutien les deux méthodes, l'une des possibles avantage est que le code dans .init est exécuté avant .ctors et le code dans .fini après .dtors. Si la commande est pertinent, c'est au moins l'un brut, mais moyen facile de distinguer entre init/sortie de fonctions.

Un inconvénient majeur est que vous ne pouvez pas facilement avoir plus d'un _init et un _fini fonction pour chaque module chargeable et aurait probablement des fragments de code en plus .so que jamais motivé. Une autre est que lors de l'utilisation de l'éditeur de liens, la méthode décrite ci-dessus, on remplace l'original _init et _fini fonctions par défaut (fourni par crti.o). C'est là où toutes sortes d'initialisation se produisent habituellement (sur Linux c'est là global affectation de variable est initialisée). Un moyen de contourner cela est décrit ici

Avis dans le lien ci-dessus qu'une cascade à l'origine _init() n'est pas nécessaire, car elle est toujours en place. Le call dans la ligne d'assemblage est cependant x86-mnémonique et l'appel d'une fonction à partir de l'assemblée serait un look complètement différent de beaucoup d'autres architectures (comme le BRAS par exemple). I. e. le code n'est pas transparent.

.init/.fini et .ctors/.detors mécanismes sont similaires, mais pas tout à fait. Code .init/.fini fonctionne "comme est". I. e. vous pouvez avoir plusieurs fonctions dans .init/.fini, mais c'est autant que je sache, la syntaxe est difficile de les mettre pleinement là de manière transparente dans le plus pur C sans en briser le code dans de nombreuses petites .so fichiers.

.ctors/.dtors sont organisées de manière différente que .init/.fini. .ctors/.dtors sections ne sont qu'à deux tables avec des pointeurs de fonctions, et le "visiteur" est fourni par le système de boucle qui appelle chaque fonction indirectement. I. e. la boucle de l'appelant peuvent être spécifiques à l'architecture, mais comme c'est une partie du système (si elle existe c'est à dire), il n'a pas d'importance.

L'extrait de code suivant ajoute de nouveaux pointeurs de fonction à la .ctors fonction de la matrice de, essentiellement de la même manière que __attribute__((constructor)) n' (méthode peut coexister avec __attribute__((constructor))).

#define SECTION( S ) __attribute__ ((section ( S )))
void test(void) {
   printf("Hello\n");
}
void (*funcptr)(void) SECTION(".ctors") =test;
void (*funcptr2)(void) SECTION(".ctors") =test;
void (*funcptr3)(void) SECTION(".dtors") =test;

On peut aussi ajouter les pointeurs de fonction pour un de complètement différent de soi-inventé la section. Une modification de linker script et une fonction supplémentaire imitant le chargeur .ctors/.dtors boucle est nécessaire dans de tels cas. Mais avec lui, on peut obtenir un meilleur contrôle sur l'exécution de la commande, ajouter en argument et le code de retour de la manipulation de l'e.t.un. (Dans un projet C++ par exemple, il serait utile si besoin de quelque chose en cours d'exécution avant ou après le mondial des constructeurs).

Je préfère __attribute__((constructor))/((destructor)) si possible, c'est une solution simple et élégante même, il se sent comme de la tricherie. Pour bare-metal programmeurs comme moi, ce n'est tout simplement pas toujours une option.

Quelques bonnes références dans le livre Linkers & chargeurs.

Ici est "concrète" (et peut-être utile) exemple de comment, pourquoi, et quand à l'utilisation de ces pratiques mais disgracieux constructions...

Xcode utilise un "global", "utilisateur par défaut" pour décider qui XCTestObserver classe vomit c'est coeur à la assiégée console.

Dans cet exemple... quand je implicitement charge de cette pseudo-bibliothèque, nous allons l'appeler... libdemure.a, par l'intermédiaire d'un drapeau dans mon test de la cible à la..

OTHER_LDFLAGS = -ldemure

Je veux..

1. À charge (c'est à dire. lorsque XCTest charges de mon test bundle), remplacer le "par défaut" XCTest "observateur" de la classe... (via le constructor fonction) PS: aussi loin Que je peux dire.. tout ce qui est fait ici pourrait être fait d'effet équivalent à l'intérieur de ma classe + (void) load { ... } méthode.

2. exécuter mes tests.... dans ce cas, avec moins inepte de verbosité dans les journaux (mise en œuvre sur demande)

3. Retour du "global" XCTestObserver classe à l'état primitif.. afin de ne pas encrasser les autres XCTest pistes qui n'ont pas pris le train en marche (aka. lié à libdemure.a). Je suppose que c'historiquement a été fait dans dealloc.. mais je ne suis pas sur le point de commencer à jouer avec cette vieille sorcière.

Donc...

#define USER_DEFS NSUserDefaults.standardUserDefaults
@interface      DemureTestObserver : XCTestObserver @end
@implementation DemureTestObserver
__attribute__((constructor)) static void hijack_observer() {
/*! here I totally hijack the default logging, but you CAN
use multiple observers, just CSV them, 
i.e. "@"DemureTestObserverm,XCTestLog"
*/
[USER_DEFS setObject:@"DemureTestObserver" 
forKey:@"XCTestObserverClass"];
[USER_DEFS synchronize];
}
__attribute__((destructor)) static void reset_observer()  {
//Clean up, and it's as if we had never been here.
[USER_DEFS setObject:@"XCTestLog" 
forKey:@"XCTestObserverClass"];
[USER_DEFS synchronize];
}
...
@end

Sans l'éditeur de liens drapeau... (de la Fashion-police de l'essaim de Cupertino exigeants châtiment, mais par défaut d'Apple l'emporte, que souhaité, ici)

AVEC le -ldemure.a de l'éditeur de liens drapeau... (Compréhensible résultats, gasp... "merci constructor/destructor"... acclamations de la Foule)