Come vedere quali flag -march = native si attiverà?

Sto compilando la mia app C ++ usando GCC 4.3. Invece di selezionare manualmente i flag di ottimizzazione che sto usando -march=native, che in teoria dovrebbe aggiungere tutti i flag di ottimizzazione applicabili all'hardware su cui sto compilando. Ma come posso verificare quali flag sta effettivamente utilizzando?

Puoi usare le -Q --help=targetopzioni:

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

L' -vopzione può anche essere utile.

Puoi vedere la documentazione --helpsull'opzione qui .

Per visualizzare i flag della riga di comando, utilizzare:

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

Se vuoi vedere il compilatore / precompilatore definito da determinati parametri, fai come segue:

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

Dovrebbe essere ( -###è simile a -v):

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

Per mostrare i "veri" flag nativi per gcc.

Puoi farli apparire più "chiaramente" con un comando:

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

e puoi sbarazzarti delle bandiere con -mno- * con:

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

Se vuoi scoprire come impostare una compilazione incrociata non nativa, ho trovato questo utile:

Sulla macchina target,

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

Quindi utilizzare questo sulla macchina di compilazione:

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

Lancerò i miei due centesimi in questa domanda e suggerirò un'estensione leggermente più dettagliata della risposta di elias. A partire da gcc 4.6, l'esecuzione di gcc -march=native -v -E - < /dev/nullemette una quantità crescente di spamming sotto forma di -mno-*flag superflui . Quanto segue eliminerà questi:

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

Tuttavia, ho verificato la correttezza di ciò solo su due diverse CPU (un Intel Core2 e AMD Phenom), quindi suggerisco di eseguire anche il seguente script per essere sicuro che tutti questi -mno-*flag possano essere rimossi in modo sicuro.

#!/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}.$$

Non ho trovato alcuna differenza tra i parametri citati gcc -march=native -v -E - < /dev/nulle gcc -march=native -### -E - < /dev/nulldiversi da quelli citati - e i parametri che non contengono caratteri speciali, quindi non sono sicuro in quali circostanze ciò faccia davvero la differenza.

Infine, nota che è --march=nativestato introdotto in gcc 4.2, prima del quale è solo un argomento non riconosciuto.