← Back to branch summary

~ubuntu-branches/ubuntu/trusty/python3.4/trusty-proposed

« back to all changes in this revision

Viewing changes to Modules/_ctypes/libffi/m4/ax_gcc_archflag.m4

  • Committer: Package Import Robot
  • Author(s): Matthias Klose
  • Date: 2013-11-25 09:44:27 UTC
  • Revision ID: package-import@ubuntu.com-20131125094427-lzxj8ap5w01lmo7f
Tags: upstream-3.4~b1
Import upstream version 3.4~b1

Show diffs side-by-side

added added

removed removed

Lines of Context:
Modules/_ctypes/libffi/m4/ax_gcc_archflag.m4
 
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@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 ' -' |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
])