Comment voir quels drapeaux -march=native va activer ?

Question

Je compile mon application C++ avec GCC 4.3. Au lieu de sélectionner manuellement les drapeaux d'optimisation, j'utilise la méthode suivante -march=native qui, en théorie, devrait ajouter tous les drapeaux d'optimisation applicables au matériel sur lequel je compile. Mais comment puis-je vérifier les drapeaux qu'il utilise réellement ?

Answer 1

Vous pouvez utiliser le -Q --help=target options :

gcc -march=native -Q --help=target ...

El -v peut également être utile.

Vous pouvez consulter la documentation sur le --help option aquí .

Answer 2

Pour voir les drapeaux de la ligne de commande, utilisez :

gcc -march=native -E -v - </dev/null 2>&1 | grep cc1

Si vous voulez voir les définitions du compilateur/précompilateur définies par certains paramètres, faites ceci :

echo | gcc -dM -E - -march=native

Answer 3

Il devrait être ( -### est similaire à -v ) :

echo | gcc -### -E - -march=native 

Pour montrer les "vrais" drapeaux natifs pour gcc.

Vous pouvez les faire apparaître plus "clairement" avec une commande :

gcc -### -E - -march=native 2>&1 | sed -r '/cc1/!d;s/(")|(^.* - )//g'

et vous pouvez vous débarrasser des drapeaux avec -mno-* avec :

gcc -### -E - -march=native 2>&1 | sed -r '/cc1/!d;s/(")|(^.* - )|( -mno-[^\ ]+)//g'

Answer 4

Si vous voulez savoir comment mettre en place une compilation croisée non native, j'ai trouvé cette page utile :

Sur la machine cible,

% gcc -march=native -Q --help=target | grep march
-march=                               core-avx-i

Puis utilisez ceci sur la machine de construction :

% gcc -march=core-avx-i ...

Answer 5

Je vais apporter mon grain de sel à cette question et suggérer une extension légèrement plus verbeuse de la réponse d'Elias. A partir de gcc 4.6, l'exécution de gcc -march=native -v -E - < /dev/null émet une quantité croissante de spam sous la forme de messages superflus. -mno-* drapeaux. Ce qui suit va les supprimer :

gcc -march=native -v -E - < /dev/null 2>&1 | grep cc1 | perl -pe 's/ -mno-\S+//g; s/^.* - //g;'

Cependant, je n'ai vérifié l'exactitude de ceci que sur deux CPU différents (un Intel Core2 et un AMD Phenom), donc je suggère d'exécuter également le script suivant pour être sûr que tous ces -mno-* peuvent être dépouillés en toute sécurité.

2021 EDIT : Il existe en effet des machines où -march=native utilise un -march valeur, mais doit désactiver certaines ISA (Instruction Set Architecture) implicites avec -mno-* .

#!/bin/bash

gcc_cmd="gcc"

# Optionally supply path to gcc as first argument
if (($#)); then
    gcc_cmd="$1"
fi

with_mno=$(
    "${gcc_cmd}" -march=native -mtune=native -v -E - < /dev/null 2>&1 |
    grep cc1 |
    perl -pe 's/^.* - //g;'
)
without_mno=$(echo "${with_mno}" | perl -pe 's/ -mno-\S+//g;')

"${gcc_cmd}" ${with_mno}    -dM -E - < /dev/null > /tmp/gcctest.a.$$
"${gcc_cmd}" ${without_mno} -dM -E - < /dev/null > /tmp/gcctest.b.$$

if diff -u /tmp/gcctest.{a,b}.$$; then
    echo "Safe to strip -mno-* options."
else
    echo
    echo "WARNING! Some -mno-* options are needed!"
    exit 1
fi

rm /tmp/gcctest.{a,b}.$$

Je n'ai pas trouvé de différence entre gcc -march=native -v -E - < /dev/null y gcc -march=native -### -E - < /dev/null à part certains paramètres qui sont cités - et les paramètres qui ne contiennent pas de caractères spéciaux, donc je ne suis pas sûr dans quelles circonstances cela fait une réelle différence.

Enfin, notez que --march=native a été introduit dans gcc 4.2, avant quoi il s'agissait simplement d'un argument non reconnu.