GCC vidage de préprocesseur

Est-il un moyen pour gcc/g++ pour vider son préprocesseur définit à partir de la ligne de commande?
Je veux dire des choses comme __GNUC__, __STDC__, et ainsi de suite.

InformationsquelleAutor Anycorn | 2010-02-08

c-preprocessor g++gcc

274

Oui, l'utilisation -E -dM options au lieu de -c.
Exemple (sorties à stdout):
```
 gcc -dM -E - < /dev/null
```
Pour C++
```
 g++ -dM -E -x c++ - < /dev/null
```
De la manuel de gcc:
Au lieu de l'habituelle sortie, de générer des
une liste de "#define " directives pour tous
les macros définies au cours de l'
l'exécution du préprocesseur,
y compris les macros prédéfinies. Cette
vous donne un moyen de savoir ce qui est
prédéfinis dans votre version de l'
préprocesseur. En supposant que vous n'avez pas de
fichier foo.h, la commande
```
touch foo.h; cpp -dM foo.h
```
affiche toutes les macros prédéfinies.

Si vous utilisez-dM sans l'option-E,
-dM est interprété comme un synonyme pour -fdump-rtl-mach.
- gcc existe sur les systèmes où /dev/null signifie rien.
- ensuite, vous pouvez utiliser un fichier vide, soit avec gcc ou le préprocesseur - rpc.
- J'ai ajouté un plus portable approche comme une alternative réponse: echo | gcc -dM -E - fonctionne sur windows ainsi.
- Est-il possible de déterminer à quel endroit (c'est à dire, dans quel fichier) les définit vient?
- Pour déterminer la source de la macro, regarde ici: stackoverflow.com/questions/11257455/...
- Sinon, sous Windows, cpp -dM -E - < NUL peut être utilisé.
- N'oubliez pas le " - x c++' option de ligne de commande si vous avez l'impression de c++ définir des macros. La commande complète est: "g++ -x c++ -dM -E - < /dev/null' pour C++ des macros spécifiques.
- L'un des plus utiles de réponses, jamais. Je reviens ici pour obtenir de l'incantation.
InformationsquelleAutor philant
75

J'ai l'habitude de le faire de cette façon:
```
$ gcc -dM -E - < /dev/null
```
Noter que certains préprocesseur sont dépendants sur les options de ligne de commande - vous pouvez le tester en ajoutant les options qui s'appliquent au-dessus de la ligne de commande. Par exemple, pour voir ce qui SSE3/SSE4 options sont activées par défaut:
```
$ gcc -dM -E - < /dev/null | grep SSE[34]
#define __SSE3__ 1
#define __SSSE3__ 1
```
et ensuite la comparer quand -msse4 est spécifié:
```
$ gcc -dM -E -msse4 - < /dev/null | grep SSE[34]
#define __SSE3__ 1
#define __SSE4_1__ 1
#define __SSE4_2__ 1
#define __SSSE3__ 1
```
De même, vous pouvez voir les options qui diffèrent entre les deux séries d'options de ligne de commande, par exemple, de comparer préprocesseur pour l'optimisation des niveaux de -O0 (aucun) et -O3 (plein):
```
$ gcc -dM -E -O0 - < /dev/null > /tmp/O0.txt
$ gcc -dM -E -O3 - < /dev/null > /tmp/O3.txt
$ sdiff -s /tmp/O0.txt /tmp/O3.txt 
#define __NO_INLINE__ 1        <
                               > #define __OPTIMIZE__ 1
```
InformationsquelleAutor Paul R
37

Réponse tardive - j'ai trouvé les autres réponses utiles - et je voulais ajouter un petit supplément.

Comment puis-je jeter les macros du préprocesseur à venir à partir d'un fichier d'en-tête?
```
echo "#include <sys/socket.h>" | gcc -E -dM -
```
En particulier, je voulais voir ce que SOMAXCONN a été définie sur mon système. Je sais que je pourrais vous suffit d'ouvrir le fichier d'en-tête standard, mais parfois, j'ai chercher un peu pour trouver le fichier d'en-tête endroits. Au lieu de cela je peux utiliser ce one-liner:
```
$ echo "#include <sys/socket.h>" | gcc -E -dM - | grep SOMAXCONN
#define SOMAXCONN 128
$ 
```
InformationsquelleAutor Digital Trauma
30

L'approche simple (gcc -dM -E - < /dev/null) fonctionne très bien pour gcc, mais échoue pour g++. Récemment, j'ai requis un test pour un C++11 Et C++14 fonctionnalité. Recommandations pour leurs noms de macro sont publiés à https://isocpp.org/std/standing-documents/sd-6-sg10-feature-test-recommendations. Mais:
```
g++ -dM -E - < /dev/null | fgrep __cpp_alias_templates
```
échoue toujours, parce qu'il silencieusement appelle la C-conducteurs (comme si invoquée par gcc). Vous pouvez le voir en comparant sa sortie contre celle de gcc ou par l'ajout d'un g++-spécifique option de ligne de commande comme (-std=c++11) qui émet le message d'erreur cc1: warning: command line option ‘-std=c++11’ is valid for C++/ObjC++ but not for C.

Parce que (non C++) gcc vous jamais soutenir les Modèles "Alias" (voir http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2258.pdf), vous devez ajouter le -x c++ option pour forcer l'invocation du compilateur C++ (Crédits pour l'utilisation de la -x c++ options à la place d'un vide fichier factice aller à yuyichao, voir ci-dessous):
```
g++ -dM -E -x c++ /dev/null | fgrep __cpp_alias_templates
```
Il n'y aura pas de sortie parce que g++ (révision 4.9.1, par défaut à -std=gnu++98) ne permet pas de C++11-fonctions par défaut. Pour ce faire, utilisez
```
g++ -dM -E -x c++ -std=c++11 /dev/null | fgrep __cpp_alias_templates
```
qui, finalement, les rendements
```
#define __cpp_alias_templates 200704
```
notant que g++ 4.9.1 prend en charge les Modèles "Alias" lorsqu'il est invoqué avec -std=c++11.
- Vous n'avez pas à utiliser un fichier fictif. GCC prend en charge la -x argument g++ -x c++ -dM -E -std=c++11 - < /dev/null | grep cpp devrait fonctionner.
- Merci à vous, ce qui rend plus facile à utiliser. Je n'étais pas au courant de l'option-x. Upvoted votre commentaire et intégré dans la réponse originale à cette question.
InformationsquelleAutor hermannk
22

Un portable approche qui fonctionne aussi bien sur Linux ou Windows (où il n'y a pas de /dev/null):
```
echo | gcc -dM -E -
```
Pour le c++, vous pouvez utiliser (remplacer c++11 avec quelle que soit la version que vous utilisez):
```
echo | gcc -x c++ -std=c++11 -dM -E -
```
Il fonctionne en disant gcc pour prétraiter stdin (qui est produite par echo) et imprimer toutes préprocesseur (recherche de -dletters). Si vous voulez savoir ce qui définit ce sont ajouté lorsque vous incluez un fichier d'en-tête vous pouvez utiliser -dD option qui est similaire à-dM, mais n'inclut pas de macros prédéfinies:
```
echo "#include <stdlib.h>" | gcc -x c++ -std=c++11 -dD -E -
```
Noter, cependant, que d'entrée vide encore produit beaucoup d'définit avec -dD option.
- c'est sans importance. le point est d'avoir en ligne de cmd qui fonctionne aussi bien sur windows et unix au moins. Si vous utilisez NUL, vous êtes de retour à la case départ: il ne fonctionne pas sur les systèmes qui n'en ont pas.
- l'ajout d'une réponse complète pour le C++, fonctionne sur Windows et Linux (bien que sort se comporte un peu différent): echo | gcc -x c++ -std=c++17 -dM -E - | sort
- Cela produit une sortie vide dans git-bash.
- a-t-elle de gcc? Dans mon git-bash je ne peux pas lancer gcc
- J'utilise mingw32 gcc qui vient avec Qt5 distribution binaire pour windows.
- Ne sais pas quoi dire. Mingw64 qui vient avec msys2 fonctionne pour moi: echo | x86_64-w64-mingw32-gcc.exe -dM -E -. Essayez de le lancer en cmd.exe pour vérifier que tout fonctionne correctement?
InformationsquelleAutor Pavel
2

Tout en travaillant dans un grand projet qui a complexe système de construction, et où il est difficile d'obtenir (ou de modifier) le gcc/g++ commande directement à il y a une autre façon de voir le résultat de l'expansion des macros.
Simplement redéfinir la macro, et vous obtenez un résultat similaire à la suivante:
```
file.h: note: this is the location of the previous definition
#define MACRO current_value
```
- Je suis à la recherche de ce que l'indicateur d'avertissement est utilisé pour cela. Le savez-vous ?
InformationsquelleAutor Piotr Pałucki

Vous devez vous connecter pour publier un commentaire.