mirror of
https://github.com/Relintai/sdl2_frt.git
synced 2024-12-29 20:27:12 +01:00
3dcb451f85
To note, this file is currently formatted with CRLF line endings, rather than LF, to allow the file to be viewed with Notepad.
216 lines
8.8 KiB
Plaintext
216 lines
8.8 KiB
Plaintext
# ===========================================================================
|
|
# http://www.gnu.org/software/autoconf-archive/ax_gcc_archflag.html
|
|
# ===========================================================================
|
|
#
|
|
# SYNOPSIS
|
|
#
|
|
# AX_GCC_ARCHFLAG([PORTABLE?], [ACTION-SUCCESS], [ACTION-FAILURE])
|
|
#
|
|
# DESCRIPTION
|
|
#
|
|
# This macro tries to guess the "native" arch corresponding to the target
|
|
# architecture for use with gcc's -march=arch or -mtune=arch flags. If
|
|
# found, the cache variable $ax_cv_gcc_archflag is set to this flag and
|
|
# ACTION-SUCCESS is executed; otherwise $ax_cv_gcc_archflag is is set to
|
|
# "unknown" and ACTION-FAILURE is executed. The default ACTION-SUCCESS is
|
|
# to add $ax_cv_gcc_archflag to the end of $CFLAGS.
|
|
#
|
|
# PORTABLE? should be either [yes] (default) or [no]. In the former case,
|
|
# the flag is set to -mtune (or equivalent) so that the architecture is
|
|
# only used for tuning, but the instruction set used is still portable. In
|
|
# the latter case, the flag is set to -march (or equivalent) so that
|
|
# architecture-specific instructions are enabled.
|
|
#
|
|
# The user can specify --with-gcc-arch=<arch> in order to override the
|
|
# macro's choice of architecture, or --without-gcc-arch to disable this.
|
|
#
|
|
# When cross-compiling, or if $CC is not gcc, then ACTION-FAILURE is
|
|
# called unless the user specified --with-gcc-arch manually.
|
|
#
|
|
# Requires macros: AX_CHECK_COMPILER_FLAGS, AX_GCC_X86_CPUID
|
|
#
|
|
# (The main emphasis here is on recent CPUs, on the principle that doing
|
|
# high-performance computing on old hardware is uncommon.)
|
|
#
|
|
# LICENSE
|
|
#
|
|
# Copyright (c) 2008 Steven G. Johnson <stevenj@alum.mit.edu>
|
|
# Copyright (c) 2008 Matteo Frigo
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify it
|
|
# under the terms of the GNU General Public License as published by the
|
|
# Free Software Foundation, either version 3 of the License, or (at your
|
|
# option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful, but
|
|
# WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
|
|
# Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License along
|
|
# with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
#
|
|
# As a special exception, the respective Autoconf Macro's copyright owner
|
|
# gives unlimited permission to copy, distribute and modify the configure
|
|
# scripts that are the output of Autoconf when processing the Macro. You
|
|
# need not follow the terms of the GNU General Public License when using
|
|
# or distributing such scripts, even though portions of the text of the
|
|
# Macro appear in them. The GNU General Public License (GPL) does govern
|
|
# all other use of the material that constitutes the Autoconf Macro.
|
|
#
|
|
# This special exception to the GPL applies to versions of the Autoconf
|
|
# Macro released by the Autoconf Archive. When you make and distribute a
|
|
# modified version of the Autoconf Macro, you may extend this special
|
|
# exception to the GPL to apply to your modified version as well.
|
|
|
|
#serial 8
|
|
|
|
AC_DEFUN([AX_GCC_ARCHFLAG],
|
|
[AC_REQUIRE([AC_PROG_CC])
|
|
AC_REQUIRE([AC_CANONICAL_HOST])
|
|
|
|
AC_ARG_WITH(gcc-arch, [AS_HELP_STRING([--with-gcc-arch=<arch>], [use architecture <arch> for gcc -march/-mtune, instead of guessing])],
|
|
ax_gcc_arch=$withval, ax_gcc_arch=yes)
|
|
|
|
AC_MSG_CHECKING([for gcc architecture flag])
|
|
AC_MSG_RESULT([])
|
|
AC_CACHE_VAL(ax_cv_gcc_archflag,
|
|
[
|
|
ax_cv_gcc_archflag="unknown"
|
|
|
|
if test "$GCC" = yes; then
|
|
|
|
if test "x$ax_gcc_arch" = xyes; then
|
|
ax_gcc_arch=""
|
|
if test "$cross_compiling" = no; then
|
|
case $host_cpu in
|
|
i[[3456]]86*|x86_64*) # use cpuid codes, in part from x86info-1.7 by D. Jones
|
|
AX_GCC_X86_CPUID(0)
|
|
AX_GCC_X86_CPUID(1)
|
|
case $ax_cv_gcc_x86_cpuid_0 in
|
|
*:756e6547:*:*) # Intel
|
|
case $ax_cv_gcc_x86_cpuid_1 in
|
|
*5[[48]]?:*:*:*) ax_gcc_arch="pentium-mmx pentium" ;;
|
|
*5??:*:*:*) ax_gcc_arch=pentium ;;
|
|
*6[[3456]]?:*:*:*) ax_gcc_arch="pentium2 pentiumpro" ;;
|
|
*6a?:*[[01]]:*:*) ax_gcc_arch="pentium2 pentiumpro" ;;
|
|
*6a?:*[[234]]:*:*) ax_gcc_arch="pentium3 pentiumpro" ;;
|
|
*6[[9d]]?:*:*:*) ax_gcc_arch="pentium-m pentium3 pentiumpro" ;;
|
|
*6[[78b]]?:*:*:*) ax_gcc_arch="pentium3 pentiumpro" ;;
|
|
*6??:*:*:*) ax_gcc_arch=pentiumpro ;;
|
|
*f3[[347]]:*:*:*|*f4[1347]:*:*:*)
|
|
case $host_cpu in
|
|
x86_64*) ax_gcc_arch="nocona pentium4 pentiumpro" ;;
|
|
*) ax_gcc_arch="prescott pentium4 pentiumpro" ;;
|
|
esac ;;
|
|
*f??:*:*:*) ax_gcc_arch="pentium4 pentiumpro";;
|
|
esac ;;
|
|
*:68747541:*:*) # AMD
|
|
case $ax_cv_gcc_x86_cpuid_1 in
|
|
*5[[67]]?:*:*:*) ax_gcc_arch=k6 ;;
|
|
*5[[8d]]?:*:*:*) ax_gcc_arch="k6-2 k6" ;;
|
|
*5[[9]]?:*:*:*) ax_gcc_arch="k6-3 k6" ;;
|
|
*60?:*:*:*) ax_gcc_arch=k7 ;;
|
|
*6[[12]]?:*:*:*) ax_gcc_arch="athlon k7" ;;
|
|
*6[[34]]?:*:*:*) ax_gcc_arch="athlon-tbird k7" ;;
|
|
*67?:*:*:*) ax_gcc_arch="athlon-4 athlon k7" ;;
|
|
*6[[68a]]?:*:*:*)
|
|
AX_GCC_X86_CPUID(0x80000006) # L2 cache size
|
|
case $ax_cv_gcc_x86_cpuid_0x80000006 in
|
|
*:*:*[[1-9a-f]]??????:*) # (L2 = ecx >> 16) >= 256
|
|
ax_gcc_arch="athlon-xp athlon-4 athlon k7" ;;
|
|
*) ax_gcc_arch="athlon-4 athlon k7" ;;
|
|
esac ;;
|
|
*f[[4cef8b]]?:*:*:*) ax_gcc_arch="athlon64 k8" ;;
|
|
*f5?:*:*:*) ax_gcc_arch="opteron k8" ;;
|
|
*f7?:*:*:*) ax_gcc_arch="athlon-fx opteron k8" ;;
|
|
*f??:*:*:*) ax_gcc_arch="k8" ;;
|
|
esac ;;
|
|
*:746e6543:*:*) # IDT
|
|
case $ax_cv_gcc_x86_cpuid_1 in
|
|
*54?:*:*:*) ax_gcc_arch=winchip-c6 ;;
|
|
*58?:*:*:*) ax_gcc_arch=winchip2 ;;
|
|
*6[[78]]?:*:*:*) ax_gcc_arch=c3 ;;
|
|
*69?:*:*:*) ax_gcc_arch="c3-2 c3" ;;
|
|
esac ;;
|
|
esac
|
|
if test x"$ax_gcc_arch" = x; then # fallback
|
|
case $host_cpu in
|
|
i586*) ax_gcc_arch=pentium ;;
|
|
i686*) ax_gcc_arch=pentiumpro ;;
|
|
esac
|
|
fi
|
|
;;
|
|
|
|
sparc*)
|
|
AC_PATH_PROG([PRTDIAG], [prtdiag], [prtdiag], [$PATH:/usr/platform/`uname -i`/sbin/:/usr/platform/`uname -m`/sbin/])
|
|
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`
|
|
cputype=`echo "$cputype" | tr -d ' -' |tr $as_cr_LETTERS $as_cr_letters`
|
|
case $cputype in
|
|
*ultrasparciv*) ax_gcc_arch="ultrasparc4 ultrasparc3 ultrasparc v9" ;;
|
|
*ultrasparciii*) ax_gcc_arch="ultrasparc3 ultrasparc v9" ;;
|
|
*ultrasparc*) ax_gcc_arch="ultrasparc v9" ;;
|
|
*supersparc*|*tms390z5[[05]]*) ax_gcc_arch="supersparc v8" ;;
|
|
*hypersparc*|*rt62[[056]]*) ax_gcc_arch="hypersparc v8" ;;
|
|
*cypress*) ax_gcc_arch=cypress ;;
|
|
esac ;;
|
|
|
|
alphaev5) ax_gcc_arch=ev5 ;;
|
|
alphaev56) ax_gcc_arch=ev56 ;;
|
|
alphapca56) ax_gcc_arch="pca56 ev56" ;;
|
|
alphapca57) ax_gcc_arch="pca57 pca56 ev56" ;;
|
|
alphaev6) ax_gcc_arch=ev6 ;;
|
|
alphaev67) ax_gcc_arch=ev67 ;;
|
|
alphaev68) ax_gcc_arch="ev68 ev67" ;;
|
|
alphaev69) ax_gcc_arch="ev69 ev68 ev67" ;;
|
|
alphaev7) ax_gcc_arch="ev7 ev69 ev68 ev67" ;;
|
|
alphaev79) ax_gcc_arch="ev79 ev7 ev69 ev68 ev67" ;;
|
|
|
|
powerpc*)
|
|
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`
|
|
cputype=`echo $cputype | sed -e 's/ppc//g;s/ *//g'`
|
|
case $cputype in
|
|
*750*) ax_gcc_arch="750 G3" ;;
|
|
*740[[0-9]]*) ax_gcc_arch="$cputype 7400 G4" ;;
|
|
*74[[4-5]][[0-9]]*) ax_gcc_arch="$cputype 7450 G4" ;;
|
|
*74[[0-9]][[0-9]]*) ax_gcc_arch="$cputype G4" ;;
|
|
*970*) ax_gcc_arch="970 G5 power4";;
|
|
*POWER4*|*power4*|*gq*) ax_gcc_arch="power4 970";;
|
|
*POWER5*|*power5*|*gr*|*gs*) ax_gcc_arch="power5 power4 970";;
|
|
603ev|8240) ax_gcc_arch="$cputype 603e 603";;
|
|
*) ax_gcc_arch=$cputype ;;
|
|
esac
|
|
ax_gcc_arch="$ax_gcc_arch powerpc"
|
|
;;
|
|
esac
|
|
fi # not cross-compiling
|
|
fi # guess arch
|
|
|
|
if test "x$ax_gcc_arch" != x -a "x$ax_gcc_arch" != xno; then
|
|
for arch in $ax_gcc_arch; do
|
|
if test "x[]m4_default([$1],yes)" = xyes; then # if we require portable code
|
|
flags="-mtune=$arch"
|
|
# -mcpu=$arch and m$arch generate nonportable code on every arch except
|
|
# x86. And some other arches (e.g. Alpha) don't accept -mtune. Grrr.
|
|
case $host_cpu in i*86|x86_64*) flags="$flags -mcpu=$arch -m$arch";; esac
|
|
else
|
|
flags="-march=$arch -mcpu=$arch -m$arch"
|
|
fi
|
|
for flag in $flags; do
|
|
AX_CHECK_COMPILER_FLAGS($flag, [ax_cv_gcc_archflag=$flag; break])
|
|
done
|
|
test "x$ax_cv_gcc_archflag" = xunknown || break
|
|
done
|
|
fi
|
|
|
|
fi # $GCC=yes
|
|
])
|
|
AC_MSG_CHECKING([for gcc architecture flag])
|
|
AC_MSG_RESULT($ax_cv_gcc_archflag)
|
|
if test "x$ax_cv_gcc_archflag" = xunknown; then
|
|
m4_default([$3],:)
|
|
else
|
|
m4_default([$2], [CFLAGS="$CFLAGS $ax_cv_gcc_archflag"])
|
|
fi
|
|
])
|