1 # =========================================================================== 2 # http://www.gnu.org/software/autoconf-archive/ax_gcc_archflag.html 3 # =========================================================================== 4 # 5 # SYNOPSIS 6 # 7 # AX_GCC_ARCHFLAG([PORTABLE?], [ACTION-SUCCESS], [ACTION-FAILURE]) 8 # 9 # DESCRIPTION 10 # 11 # This macro tries to guess the "native" arch corresponding to the target 12 # architecture for use with gcc's -march=arch or -mtune=arch flags. If 13 # found, the cache variable $ax_cv_gcc_archflag is set to this flag and 14 # ACTION-SUCCESS is executed; otherwise $ax_cv_gcc_archflag is set to 15 # "unknown" and ACTION-FAILURE is executed. The default ACTION-SUCCESS is 16 # to add $ax_cv_gcc_archflag to the end of $CFLAGS. 17 # 18 # PORTABLE? should be either [yes] (default) or [no]. In the former case, 19 # the flag is set to -mtune (or equivalent) so that the architecture is 20 # only used for tuning, but the instruction set used is still portable. In 21 # the latter case, the flag is set to -march (or equivalent) so that 22 # architecture-specific instructions are enabled. 23 # 24 # The user can specify --with-gcc-arch=<arch> in order to override the 25 # macro's choice of architecture, or --without-gcc-arch to disable this. 26 # 27 # When cross-compiling, or if $CC is not gcc, then ACTION-FAILURE is 28 # called unless the user specified --with-gcc-arch manually. 29 # 30 # Requires macros: AX_CHECK_COMPILE_FLAG, AX_GCC_X86_CPUID 31 # 32 # (The main emphasis here is on recent CPUs, on the principle that doing 33 # high-performance computing on old hardware is uncommon.) 34 # 35 # LICENSE 36 # 37 # Copyright (c) 2008 Steven G. Johnson <stevenj (a] alum.mit.edu> 38 # Copyright (c) 2008 Matteo Frigo 39 # Copyright (c) 2012 Tsukasa Oi 40 # 41 # This program is free software: you can redistribute it and/or modify it 42 # under the terms of the GNU General Public License as published by the 43 # Free Software Foundation, either version 3 of the License, or (at your 44 # option) any later version. 45 # 46 # This program is distributed in the hope that it will be useful, but 47 # WITHOUT ANY WARRANTY; without even the implied warranty of 48 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General 49 # Public License for more details. 50 # 51 # You should have received a copy of the GNU General Public License along 52 # with this program. If not, see <http://www.gnu.org/licenses/>. 53 # 54 # As a special exception, the respective Autoconf Macro's copyright owner 55 # gives unlimited permission to copy, distribute and modify the configure 56 # scripts that are the output of Autoconf when processing the Macro. You 57 # need not follow the terms of the GNU General Public License when using 58 # or distributing such scripts, even though portions of the text of the 59 # Macro appear in them. The GNU General Public License (GPL) does govern 60 # all other use of the material that constitutes the Autoconf Macro. 61 # 62 # This special exception to the GPL applies to versions of the Autoconf 63 # Macro released by the Autoconf Archive. When you make and distribute a 64 # modified version of the Autoconf Macro, you may extend this special 65 # exception to the GPL to apply to your modified version as well. 66 67 #serial 11 68 69 AC_DEFUN([AX_GCC_ARCHFLAG], 70 [AC_REQUIRE([AC_PROG_CC]) 71 AC_REQUIRE([AC_CANONICAL_HOST]) 72 73 AC_ARG_WITH(gcc-arch, [AS_HELP_STRING([--with-gcc-arch=<arch>], [use architecture <arch> for gcc -march/-mtune, instead of guessing])], 74 ax_gcc_arch=$withval, ax_gcc_arch=yes) 75 76 AC_MSG_CHECKING([for gcc architecture flag]) 77 AC_MSG_RESULT([]) 78 AC_CACHE_VAL(ax_cv_gcc_archflag, 79 [ 80 ax_cv_gcc_archflag="unknown" 81 82 if test "$GCC" = yes; then 83 84 if test "x$ax_gcc_arch" = xyes; then 85 ax_gcc_arch="" 86 if test "$cross_compiling" = no; then 87 case $host_cpu in 88 i[[3456]]86*|x86_64*) # use cpuid codes 89 AX_GCC_X86_CPUID(0) 90 AX_GCC_X86_CPUID(1) 91 case $ax_cv_gcc_x86_cpuid_0 in 92 *:756e6547:*:*) # Intel 93 case $ax_cv_gcc_x86_cpuid_1 in 94 *5[[48]]?:*:*:*) ax_gcc_arch="pentium-mmx pentium" ;; 95 *5??:*:*:*) ax_gcc_arch=pentium ;; 96 *0?6[[3456]]?:*:*:*) ax_gcc_arch="pentium2 pentiumpro" ;; 97 *0?6a?:*[[01]]:*:*) ax_gcc_arch="pentium2 pentiumpro" ;; 98 *0?6a?:*[[234]]:*:*) ax_gcc_arch="pentium3 pentiumpro" ;; 99 *0?6[[9de]]?:*:*:*) ax_gcc_arch="pentium-m pentium3 pentiumpro" ;; 100 *0?6[[78b]]?:*:*:*) ax_gcc_arch="pentium3 pentiumpro" ;; 101 *0?6f?:*:*:*|*1?66?:*:*:*) ax_gcc_arch="core2 pentium-m pentium3 pentiumpro" ;; 102 *1?6[[7d]]?:*:*:*) ax_gcc_arch="penryn core2 pentium-m pentium3 pentiumpro" ;; 103 *1?6[[aef]]?:*:*:*|*2?6[[5cef]]?:*:*:*) ax_gcc_arch="corei7 core2 pentium-m pentium3 pentiumpro" ;; 104 *1?6c?:*:*:*|*[[23]]?66?:*:*:*) ax_gcc_arch="atom core2 pentium-m pentium3 pentiumpro" ;; 105 *2?6[[ad]]?:*:*:*) ax_gcc_arch="corei7-avx corei7 core2 pentium-m pentium3 pentiumpro" ;; 106 *0?6??:*:*:*) ax_gcc_arch=pentiumpro ;; 107 *6??:*:*:*) ax_gcc_arch="core2 pentiumpro" ;; 108 ?000?f3[[347]]:*:*:*|?000?f4[1347]:*:*:*|?000?f6?:*:*:*) 109 case $host_cpu in 110 x86_64*) ax_gcc_arch="nocona pentium4 pentiumpro" ;; 111 *) ax_gcc_arch="prescott pentium4 pentiumpro" ;; 112 esac ;; 113 ?000?f??:*:*:*) ax_gcc_arch="pentium4 pentiumpro";; 114 esac ;; 115 *:68747541:*:*) # AMD 116 case $ax_cv_gcc_x86_cpuid_1 in 117 *5[[67]]?:*:*:*) ax_gcc_arch=k6 ;; 118 *5[[8d]]?:*:*:*) ax_gcc_arch="k6-2 k6" ;; 119 *5[[9]]?:*:*:*) ax_gcc_arch="k6-3 k6" ;; 120 *60?:*:*:*) ax_gcc_arch=k7 ;; 121 *6[[12]]?:*:*:*) ax_gcc_arch="athlon k7" ;; 122 *6[[34]]?:*:*:*) ax_gcc_arch="athlon-tbird k7" ;; 123 *67?:*:*:*) ax_gcc_arch="athlon-4 athlon k7" ;; 124 *6[[68a]]?:*:*:*) 125 AX_GCC_X86_CPUID(0x80000006) # L2 cache size 126 case $ax_cv_gcc_x86_cpuid_0x80000006 in 127 *:*:*[[1-9a-f]]??????:*) # (L2 = ecx >> 16) >= 256 128 ax_gcc_arch="athlon-xp athlon-4 athlon k7" ;; 129 *) ax_gcc_arch="athlon-4 athlon k7" ;; 130 esac ;; 131 ?00??f[[4cef8b]]?:*:*:*) ax_gcc_arch="athlon64 k8" ;; 132 ?00??f5?:*:*:*) ax_gcc_arch="opteron k8" ;; 133 ?00??f7?:*:*:*) ax_gcc_arch="athlon-fx opteron k8" ;; 134 ?00??f??:*:*:*) ax_gcc_arch="k8" ;; 135 ?05??f??:*:*:*) ax_gcc_arch="btver1 amdfam10 k8" ;; 136 ?06??f??:*:*:*) ax_gcc_arch="bdver1 amdfam10 k8" ;; 137 *f??:*:*:*) ax_gcc_arch="amdfam10 k8" ;; 138 esac ;; 139 *:746e6543:*:*) # IDT 140 case $ax_cv_gcc_x86_cpuid_1 in 141 *54?:*:*:*) ax_gcc_arch=winchip-c6 ;; 142 *58?:*:*:*) ax_gcc_arch=winchip2 ;; 143 *6[[78]]?:*:*:*) ax_gcc_arch=c3 ;; 144 *69?:*:*:*) ax_gcc_arch="c3-2 c3" ;; 145 esac ;; 146 esac 147 if test x"$ax_gcc_arch" = x; then # fallback 148 case $host_cpu in 149 i586*) ax_gcc_arch=pentium ;; 150 i686*) ax_gcc_arch=pentiumpro ;; 151 esac 152 fi 153 ;; 154 155 sparc*) 156 AC_PATH_PROG([PRTDIAG], [prtdiag], [prtdiag], [$PATH:/usr/platform/`uname -i`/sbin/:/usr/platform/`uname -m`/sbin/]) 157 cputype=`(((grep cpu /proc/cpuinfo | cut -d: -f2) ; ($PRTDIAG -v |grep -i sparc) ; grep -i cpu /var/run/dmesg.boot ) | head -n 1) 2> /dev/null` 158 cputype=`echo "$cputype" | tr -d ' -' | sed 's/SPARCIIi/SPARCII/' | tr $as_cr_LETTERS $as_cr_letters` 159 case $cputype in 160 *ultrasparciv*) ax_gcc_arch="ultrasparc4 ultrasparc3 ultrasparc v9" ;; 161 *ultrasparciii*) ax_gcc_arch="ultrasparc3 ultrasparc v9" ;; 162 *ultrasparc*) ax_gcc_arch="ultrasparc v9" ;; 163 *supersparc*|*tms390z5[[05]]*) ax_gcc_arch="supersparc v8" ;; 164 *hypersparc*|*rt62[[056]]*) ax_gcc_arch="hypersparc v8" ;; 165 *cypress*) ax_gcc_arch=cypress ;; 166 esac ;; 167 168 alphaev5) ax_gcc_arch=ev5 ;; 169 alphaev56) ax_gcc_arch=ev56 ;; 170 alphapca56) ax_gcc_arch="pca56 ev56" ;; 171 alphapca57) ax_gcc_arch="pca57 pca56 ev56" ;; 172 alphaev6) ax_gcc_arch=ev6 ;; 173 alphaev67) ax_gcc_arch=ev67 ;; 174 alphaev68) ax_gcc_arch="ev68 ev67" ;; 175 alphaev69) ax_gcc_arch="ev69 ev68 ev67" ;; 176 alphaev7) ax_gcc_arch="ev7 ev69 ev68 ev67" ;; 177 alphaev79) ax_gcc_arch="ev79 ev7 ev69 ev68 ev67" ;; 178 179 powerpc*) 180 cputype=`((grep cpu /proc/cpuinfo | head -n 1 | cut -d: -f2 | cut -d, -f1 | sed 's/ //g') ; /usr/bin/machine ; /bin/machine; grep CPU /var/run/dmesg.boot | head -n 1 | cut -d" " -f2) 2> /dev/null` 181 cputype=`echo $cputype | sed -e 's/ppc//g;s/ *//g'` 182 case $cputype in 183 *750*) ax_gcc_arch="750 G3" ;; 184 *740[[0-9]]*) ax_gcc_arch="$cputype 7400 G4" ;; 185 *74[[4-5]][[0-9]]*) ax_gcc_arch="$cputype 7450 G4" ;; 186 *74[[0-9]][[0-9]]*) ax_gcc_arch="$cputype G4" ;; 187 *970*) ax_gcc_arch="970 G5 power4";; 188 *POWER4*|*power4*|*gq*) ax_gcc_arch="power4 970";; 189 *POWER5*|*power5*|*gr*|*gs*) ax_gcc_arch="power5 power4 970";; 190 603ev|8240) ax_gcc_arch="$cputype 603e 603";; 191 *) ax_gcc_arch=$cputype ;; 192 esac 193 ax_gcc_arch="$ax_gcc_arch powerpc" 194 ;; 195 esac 196 fi # not cross-compiling 197 fi # guess arch 198 199 if test "x$ax_gcc_arch" != x -a "x$ax_gcc_arch" != xno; then 200 for arch in $ax_gcc_arch; do 201 if test "x[]m4_default([$1],yes)" = xyes; then # if we require portable code 202 flags="-mtune=$arch" 203 # -mcpu=$arch and m$arch generate nonportable code on every arch except 204 # x86. And some other arches (e.g. Alpha) don't accept -mtune. Grrr. 205 case $host_cpu in i*86|x86_64*) flags="$flags -mcpu=$arch -m$arch";; esac 206 else 207 flags="-march=$arch -mcpu=$arch -m$arch" 208 fi 209 for flag in $flags; do 210 AX_CHECK_COMPILE_FLAG($flag, [ax_cv_gcc_archflag=$flag; break]) 211 done 212 test "x$ax_cv_gcc_archflag" = xunknown || break 213 done 214 fi 215 216 fi # $GCC=yes 217 ]) 218 AC_MSG_CHECKING([for gcc architecture flag]) 219 AC_MSG_RESULT($ax_cv_gcc_archflag) 220 if test "x$ax_cv_gcc_archflag" = xunknown; then 221 m4_default([$3],:) 222 else 223 m4_default([$2], [CFLAGS="$CFLAGS $ax_cv_gcc_archflag"]) 224 fi 225 ]) 226
