prévenir la gcc à partir de la suppression d'une variable inutilisée

Dans nos fichiers source, nous avons habituellement une chaîne de version comme ça:

static const char srcvers[] = "VERSION/foo.c/1.01/09.04.15";

Lorsque la chaîne n'est pas optimisé, il est très utile dans certains cas, comme on peut déterminer la version de chaque fichier source lié à un fichier exécutable en appelant simplement strings a.out | grep VERSION.

Malheureusement, il est optimisé à l'écart par gcc (en utilisant l'option '-O'). Donc ma question est, est-il un moyen simple (un commutateur de compilateur serait génial) pour faire de la gcc garder cette variable (son nom est toujours le même) sans éteindre toutes les autres optimisations.

Modifier

Ce qui, à mon avis, la question est-elle différente de que l'on, c'est que je suis a été l'espoir de trouver une solution pour que je ne touchez pas à des milliers de fichiers source.

Qu'en est ajouter -v option sur tous vos binaires affichage de ce var ?
Peut-être essayer de tromper gcc en pensant que la variable est utilisée (quelque chose comme strlen(srcvers);)?
Essayé de faire volatile? Cela devrait fonctionner: volatile static const char srcvers[] = "VERSION/foo.c/1.01/09.04.15";
voulez-vous dire a.out -v? qui travaillent pour un fichier source seulement, et nous le faisons déjà. Je voudrais obtenir des informations sur tous les fichiers liés ensemble
double possible de Comment prévenir l'optimisation du compilateur sur un petit morceau de code?

OriginalL'auteur Ingo Leonhardt | 2015-04-09

  1. 22

    Vous pouvez utiliser __attribute__((used)) gcc (fonctionne aussi dans clang) spécifique (je vois que la question est balisé gcc) attributs pour cette:

    Cet attribut, attaché à une fonction, signifie que le code doit être émise pour la fonction, même s'il semble que la fonction n'est pas référencé. Ceci est utile, par exemple, lorsque la fonction est référencé uniquement dans un assembly en ligne.

    De https://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html

    Démo:

    $ cat a.c
static const char srcvers[] __attribute__((used)) = "VERSION/foo.c/1.01/09.04.15";
$ gcc -O3 -c a.c
$ strings a.o
VERSION/foo.c/1.01/09.04.15

    Vous pouvez utiliser certains #ifs et #defines pour faire de cette terser et aussi compiler sur des compilateurs qui ne prennent pas en charge cette extension.

    Bien que la documentation extrait décrit l'utilisation de cet attribut avec les fonctions, le même attribut peut également être utilisé avec des variables, à condition qu'ils aient mémoire statique (comme dans ce cas).
    excellente idée, merci. Mais la solution idéale pour l'été où je n'aurais pas besoin de modifier chaque fichier source.
    vous pouvez faire quelque chose de similaire avec un linker script.
    pourriez-vous point que, s'il vous plaît?
    stackoverflow.com/questions/9827157/...

    OriginalL'auteur Dogbert

  2. 4

    Que je comprends de votre question, vous devez ajouter de la chaîne de version de chaque fichier de l'objet sans le toucher sources. Il peut être fait en utilisant le moyen suivant.

    Créer fichier d'en-tête, par exemple include/version.h:

    #ifndef VERSION_H
#define VERSION_H

static const char _ver[] __attribute__((used)) = "VERSION/foo.c/1.01/09.04.15";

#endif /* VERSION_H */

    Puis dans votre Makefile (ou quel que soit votre système de construction est) ajouter à côté gcc drapeau:

    CPPFLAGS += -include include/version.h

    Bien sûr, il doit être transmis à gcc, par exemple comme ceci:

    %.o: %.c
    $(CC) $(CFLAGS) $(CPPFLAGS) -o $(*).o -c $(*).c

    Maintenant, vous pouvez observer votre _ver chaîne compilé pour chaque fichier objet:

    $ objdump -DS src/main.o | grep _ver

    Qui va vous montrer quelque chose comme ça:

    Disassembly of section .rodata._ver:
00000000 <_ver>:
    la chaîne de version est déjà là, mais sont optimisés (et bien sûr j'ai besoin de ça, avec des dates comme "03.01.01', certains fichiers sont vraiment vieux). Mais l'idée wih -include sent un peu comme j'ai pu l'utiliser pour résoudre le problème de toute façon. Merci encore
    Ah, vos fichiers source sont disponibles dans différentes versions, je vois. La pensée que la version stands pour le projet lui-même.
    nan ce serait trop facile (en fait, c'est une information supplémentaire que nous avons déjà, mais parfois vous avez juste besoin d'être sûr que si un certain changement dans un fichier inclus par une bibliothèque .. est lié ou pas)
    Et bien, le meilleur moyen pour résoudre ce problème est alors de modifier le code dans chaque fichier source (ajout de __attribute__((used))). Il peut être fait facilement avec bash oneliner, à l'aide de find et sed commandes. Avez-vous quelque chose empêcher de vous le faire?
    oui bien sûr, mais je veux vraiment vieux fichiers restent littéralement les vieux. Outre les fichiers sont archivés dans un scc version du système de contrôle (ai-je déjà mentionné "vieux"?) mais que serait résoluble, bien sûr.

    OriginalL'auteur Sam Protsenko

  3. 2

    Déclarer la variable comme volatile peut également aider. C'est pourquoi il est utilisé en premier lieu, la prévention de toutes les optimisations du compilateur qui concerne cette variable.

    Il aide vraiment; j'ai déjà vérifié. Mais encore une fois, cela signifierait toucher de chaque dossier :-(. Merci quand même
    Notez que c'est mise en œuvre défini. Il n'y a aucune garantie que cela fonctionne, que la norme exige seulement que volatile affecte accède à la variable. Si la variable n'est jamais utilisé, compilateur peut le retirer librement.

    OriginalL'auteur nikaltipar

  4. 1

    Car il semble que toutes les solutions exigent une sorte de décoration de la chaîne de version dans la source, il peut aider à définir une macro contenant tout le nécessaire à la syntaxe et ensuite utiliser cette macro dans la source ou les fichiers d'en-tête à chaque fois que de besoin:

    #define SRCVERSION(file, version, data) static const char _ver[] __attribute__((used)) = "VERSION/" file "/" version "/" date;

    Puis dans votre source vient de mettre

    SRCVERSION("foo.c", "1.01", "09.04.15")

    La macro peut être dans un projet central de l'en-tête de fichier ou sur la ligne de commande du compilateur.

    De cette façon, au moins vous n'avez pas à toucher tous les fichiers source de nouveau si vous voulez changer quelque chose à propos de la définition.

    Notez comment la définition de la macro utilise la concaténation de chaîne de construire la version finale de la chaîne.
    Il contient également le point-virgule final de sorte que vous pouvez supprimer tout par la définition d'un vide macro si nécessaire.

    OriginalL'auteur Ber

  5. 0

    Vous êtes préoccupé par gcc la suppression d'un inutilisés static char[] variable. Autant que je sache, le compilateur est en droit de le faire.

    D'autres réponses fournies suggestion pour l'améliorer. Mais vous ne voulez pas modifier le code source de milliers de fichiers.

    Alors, vous pourriez peut-être changer votre construction (par exemple, certains Makefile), de sorte que chaque fichier source à l'aide de votre tour (ce qui est un peu mal, comme discuté ici...) n'auraient pas besoin d'être changé. Donc, vous pourriez invoquer GCC spécifiquement. Vous souhaitez

     static const char _ver[] __attribute__((used));

    (c'est une déclaration, pas une définition) pour être compilé avant toute autre chose. Mettre la ligne ci-dessus dans certains _declare_ver.h fichier, et de compiler avec gcc -include _declare_ver.h de commande (au lieu de gcc). Si vous utilisez make ajouter

     CFLAGS += -include _declare_ver.h

    dans votre Makefile.

    BTW, c'est un sale coup. Vous devriez envisager de faire quelque chose de mieux (à la suite d'autres réponses).

    OriginalL'auteur Basile Starynkevitch