summaryrefslogtreecommitdiff
path: root/Build/source/libs/gmp/gmp-6.0.0/configgmp.guess
diff options
context:
space:
mode:
Diffstat (limited to 'Build/source/libs/gmp/gmp-6.0.0/configgmp.guess')
-rwxr-xr-xBuild/source/libs/gmp/gmp-6.0.0/configgmp.guess1021
1 files changed, 1021 insertions, 0 deletions
diff --git a/Build/source/libs/gmp/gmp-6.0.0/configgmp.guess b/Build/source/libs/gmp/gmp-6.0.0/configgmp.guess
new file mode 100755
index 00000000000..02b61f45aaf
--- /dev/null
+++ b/Build/source/libs/gmp/gmp-6.0.0/configgmp.guess
@@ -0,0 +1,1021 @@
+#! /bin/sh
+#
+# GMP config.guess wrapper.
+
+
+# Copyright 2000-2006, 2008, 2011-2014 Free Software Foundation, Inc.
+#
+# This file is part of the GNU MP Library.
+#
+# The GNU MP Library is free software; you can redistribute it and/or modify
+# it under the terms of either:
+#
+# * the GNU Lesser General Public License as published by the Free
+# Software Foundation; either version 3 of the License, or (at your
+# option) any later version.
+#
+# or
+#
+# * the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any
+# later version.
+#
+# or both in parallel, as here.
+#
+# The GNU MP Library 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 copies of the GNU General Public License and the
+# GNU Lesser General Public License along with the GNU MP Library. If not,
+# see https://www.gnu.org/licenses/.
+
+
+# Usage: config.guess
+#
+# Print the host system CPU-VENDOR-OS.
+#
+# configfsf.guess is run and its guess then sharpened up to take advantage
+# of the finer grained CPU types that GMP knows.
+
+
+# Expect to find configfsf.guess in the same directory as this config.guess
+configfsf_guess="`echo \"$0\" | sed 's/config.guess$/configfsf.guess/'`"
+if test "$configfsf_guess" = "$0"; then
+ echo "Cannot derive configfsf.guess from $0" 1>&2
+ exit 1
+fi
+if test -f "$configfsf_guess"; then
+ :
+else
+ echo "$configfsf_guess not found" 1>&2
+ exit 1
+fi
+
+# Setup a $SHELL with which to run configfsf.guess, using the same
+# $CONFIG_SHELL or /bin/sh as autoconf does when running config.guess
+SHELL=${CONFIG_SHELL-/bin/sh}
+
+# Identify ourselves on --version, --help or errors
+if test $# != 0; then
+ echo "(GNU MP wrapped config.guess)"
+ $SHELL $configfsf_guess "$@"
+ exit 1
+fi
+
+guess_full=`$SHELL $configfsf_guess`
+if test $? != 0; then
+ exit 1
+fi
+
+guess_cpu=`echo "$guess_full" | sed 's/-.*$//'`
+guess_rest=`echo "$guess_full" | sed 's/^[^-]*//'`
+exact_cpu=
+
+
+# -------------------------------------------------------------------------
+# The following should look at the current guess and probe the system to
+# establish a better guess in exact_cpu. Leave exact_cpu empty if probes
+# can't be done, or don't work.
+#
+# When a number of probes are done, test -z "$exact_cpu" can be used instead
+# of putting each probe under an "else" of the preceeding. That can stop
+# the code getting horribly nested and marching off the right side of the
+# screen.
+
+# Note that when a compile-and-link is done in one step we need to remove .o
+# files, since lame C compilers generate these even when not asked.
+#
+
+# CC_FOR_BUILD -- compiler used by this script. Note that the use of a
+# compiler to aid in system detection is discouraged as it requires
+# temporary files to be created and, as you can see below, it is a
+# headache to deal with in a portable fashion.
+
+# Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still
+# use `HOST_CC' if defined, but it is deprecated.
+
+# Portable tmp directory creation inspired by the Autoconf team.
+
+set_cc_for_build='
+trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ;
+trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ;
+: ${TMPDIR=/tmp} ;
+ { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } ||
+ { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } ||
+ { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } ||
+ { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ;
+dummy=$tmp/dummy ;
+tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy $dummy.core ${dummy}0.s" ;
+case $CC_FOR_BUILD,$HOST_CC,$CC in
+ ,,) echo "int x;" > $dummy.c ;
+ for c in cc gcc c89 c99 ; do
+ if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then
+ CC_FOR_BUILD="$c"; break ;
+ fi ;
+ done ;
+ if test x"$CC_FOR_BUILD" = x ; then
+ CC_FOR_BUILD=no_compiler_found ;
+ fi
+ ;;
+ ,,*) CC_FOR_BUILD=$CC ;;
+ ,*,*) CC_FOR_BUILD=$HOST_CC ;;
+esac ; set_cc_for_build= ;'
+
+
+case "$guess_full" in
+
+alpha-*-*)
+ eval $set_cc_for_build
+ # configfsf.guess detects exact alpha cpu types for OSF and GNU/Linux, but
+ # not for *BSD and other systems. We try to get an exact type for any
+ # plain "alpha" it leaves.
+ #
+ # configfsf.guess used to have a block of code not unlike this, but these
+ # days does its thing with Linux kernel /proc/cpuinfo or OSF psrinfo.
+ #
+ cat <<EOF >${dummy}0.s
+ .data
+Lformat:
+ .byte 37,100,45,37,120,10,0 # "%d-%x\n"
+ .text
+ .globl main
+ .align 4
+ .ent main
+main:
+ .frame \$30,16,\$26,0
+ ldgp \$29,0(\$27)
+ .prologue 1
+ .long 0x47e03d91 # implver \$17
+ lda \$2,-1
+ .long 0x47e20c21 # amask \$2,\$1
+ lda \$16,Lformat
+ not \$1,\$18
+ jsr \$26,printf
+ ldgp \$29,0(\$26)
+ mov 0,\$16
+ jsr \$26,exit
+ .end main
+EOF
+ $CC_FOR_BUILD ${dummy}0.s -o $dummy 2>/dev/null
+ if test "$?" = 0 ; then
+ case `$dummy` in
+ 0-0) exact_cpu=alpha ;;
+ 1-0) exact_cpu=alphaev5 ;;
+ 1-1) exact_cpu=alphaev56 ;;
+ 1-101) exact_cpu=alphapca56 ;;
+ 2-303) exact_cpu=alphaev6 ;;
+ 2-307) exact_cpu=alphaev67 ;;
+ 2-1307) exact_cpu=alphaev68 ;;
+ esac
+ fi
+ ;;
+
+arm*-*-*)
+ cpu_code=`sed -n 's/^CPU part.*\(0x.*\)$/\1/p' /proc/cpuinfo 2>/dev/null`
+ case "$cpu_code" in
+ 0xa10 | 0xa11 | 0xb11) # v4 strongarm/sa1100
+ exact_cpu="armsa1";;
+ 0x915 | 0x925 | \
+ 0x920 | 0x922 | 0x940) # v4
+ exact_cpu="arm9tdmi";;
+ 0x210 | 0x290 | 0x2d0 | \
+ 0x212 | 0x292 | 0x2d2 | \
+ 0x411) exact_cpu="armxscale";; # v5 pxa2xx
+ 0x926 | 0x946 | 0x966 | 0x968) # v5te/v5tej
+ exact_cpu="arm9te";;
+ 0xa20 | 0xa22 | 0xa26) # v5te
+ exact_cpu="arm10";;
+ 0xb02) exact_cpu="arm11mpcore";; # v6
+ 0xb36) exact_cpu="arm1136";; # v6
+ 0xb56) exact_cpu="arm1156";; # v6t2
+ 0xb76) exact_cpu="arm1176";; # v6
+ 0xc05) exact_cpu="armcortexa5";; # v7a
+ 0xc07) exact_cpu="armcortexa7";; # v7a
+ 0xc08) exact_cpu="armcortexa8";; # v7a
+ 0xc09) exact_cpu="armcortexa9";; # v7a
+ 0xc0f) exact_cpu="armcortexa15";; # v7a
+ 0xc14) exact_cpu="armcortexr4";; # v7r
+ 0xc15) exact_cpu="armcortexr5";; # v7r
+ 0xc23) exact_cpu="armcortexm3";; # v7m
+ esac
+ exact_cpu="${exact_cpu}`sed -n 's;^Features.*\(neon\).*;\1;p' /proc/cpuinfo 2>/dev/null`"
+ ;;
+
+ia64*-*-*)
+ eval $set_cc_for_build
+ # CPUID[3] bits 24 to 31 is the processor family. itanium2 is documented
+ # as 0x1f, plain itanium has been seen returning 0x07 on two systems, but
+ # haven't found any documentation on it as such.
+ #
+ # Defining both getcpuid and _getcpuid lets us ignore whether the system
+ # expects underscores or not.
+ #
+ # "unsigned long long" is always 64 bits, in fact on hpux in ilp32 mode
+ # (which is the default there), it's the only 64-bit type.
+ #
+ cat >${dummy}0.s <<EOF
+ .text
+ .global _getcpuid
+ .proc _getcpuid
+_getcpuid:
+ mov r8 = CPUID[r32] ;;
+ br.ret.sptk.many rp ;;
+ .endp _getcpuid
+ .global getcpuid
+ .proc getcpuid
+getcpuid:
+ mov r8 = CPUID[r32] ;;
+ br.ret.sptk.many rp ;;
+ .endp getcpuid
+EOF
+ cat >$dummy.c <<EOF
+#include <stdio.h>
+unsigned long long getcpuid ();
+int
+main ()
+{
+ if (getcpuid(0LL) == 0x49656E69756E6547LL && getcpuid(1LL) == 0x6C65746ELL)
+ {
+ /* "GenuineIntel" */
+ switch ((getcpuid(3LL) >> 24) & 0xFF) {
+ case 0x07: puts ("itanium"); break;
+ case 0x1F: puts ("itanium2"); break; /* McKinley, Madison */
+ case 0x20: puts ("itanium2"); break; /* Montecito */
+ }
+ }
+ return 0;
+}
+EOF
+ if $CC_FOR_BUILD ${dummy}0.s $dummy.c -o $dummy >/dev/null 2>&1; then
+ exact_cpu=`$dummy`
+ fi
+ ;;
+
+mips-*-irix[6789]*)
+ # IRIX 6 and up always has a 64-bit mips cpu
+ exact_cpu=mips64
+ ;;
+
+m68k-*-*)
+ eval $set_cc_for_build
+ # NetBSD (and presumably other *BSD) "sysctl hw.model" gives for example
+ # hw.model = Apple Macintosh Quadra 610 (68040)
+ exact_cpu=`(sysctl hw.model) 2>/dev/null | sed -n 's/^.*\(680[012346]0\).*$/m\1/p'`
+ if test -z "$exact_cpu"; then
+ # Linux kernel 2.2 gives for example "CPU: 68020" (tabs in between).
+ exact_cpu=`sed -n 's/^CPU:.*\(680[012346]0\).*$/m\1/p' /proc/cpuinfo 2>/dev/null`
+ fi
+ if test -z "$exact_cpu"; then
+ # Try: movel #0,%d0; rts
+ # This is to check the compiler and our asm code works etc, before
+ # assuming failures below indicate cpu characteristics.
+ # .byte is used to avoid problems with assembler syntax variations.
+ # For testing, provoke failures by adding "illegal" possibly as
+ # ".byte 0x4A, 0xFC"
+ cat >${dummy}0.s <<EOF
+ .text
+ .globl main
+ .globl _main
+main:
+_main:
+ .byte 0x70, 0x00
+ .byte 0x4e, 0x75
+EOF
+
+ if ($CC_FOR_BUILD ${dummy}0.s -o $dummy && $dummy) >/dev/null 2>&1; then
+
+ # $SHELL -c is used to execute $dummy below, since ($dummy)
+ # 2>/dev/null still prints the SIGILL message on some shells.
+ #
+ # Try: movel #0,%d0
+ # rtd #0
+ cat >${dummy}0.s <<EOF
+ .text
+ .globl main
+ .globl _main
+main:
+_main:
+ .byte 0x70, 0x00
+ .byte 0x4e, 0x74, 0x00, 0x00
+EOF
+ if $CC_FOR_BUILD ${dummy}0.s -o $dummy >/dev/null 2>&1; then
+ $SHELL -c $dummy >/dev/null 2>&1
+ if test $? != 0; then
+ exact_cpu=m68000 # because rtd didn't work
+ fi
+ fi
+ #
+
+ if test -z "$exact_cpu"; then
+ # Try: trapf
+ # movel #0,%d0
+ # rts
+ # Another possibility for identifying 68000 and 68010 is the
+ # different value stored by "movem a0,(a0)+"
+ cat >${dummy}0.s <<EOF
+ .text
+ .globl main
+ .globl _main
+main:
+_main:
+ .byte 0x51, 0xFC
+ .byte 0x70, 0x00
+ .byte 0x4e, 0x75
+EOF
+ if $CC_FOR_BUILD ${dummy}0.s -o $dummy >/dev/null 2>&1; then
+ $SHELL -c $dummy >/dev/null 2>&1
+ if test $? != 0; then
+ exact_cpu=m68010 # because trapf didn't work
+ fi
+ fi
+ fi
+
+ if test -z "$exact_cpu"; then
+ # Try: bfffo %d1{0:31},%d0
+ # movel #0,%d0
+ # rts
+ cat >${dummy}0.s <<EOF
+ .text
+ .globl main
+ .globl _main
+main:
+_main:
+ .byte 0xED, 0xC1, 0x00, 0x1F
+ .byte 0x70, 0x00
+ .byte 0x4e, 0x75
+EOF
+ if $CC_FOR_BUILD ${dummy}0.s -o $dummy >/dev/null 2>&1; then
+ $SHELL -c $dummy >/dev/null 2>&1
+ if test $? != 0; then
+ exact_cpu=m68360 # cpu32, because bfffo didn't work
+ fi
+ fi
+ fi
+
+ if test -z "$exact_cpu"; then
+ # FIXME: Now we know 68020 or up, but how to detect 030, 040 and 060?
+ exact_cpu=m68020
+ fi
+ fi
+ fi
+ if test -z "$exact_cpu"; then
+ case "$guess_full" in
+ *-*-next* | *-*-openstep*) # NeXTs are 68020 or better
+ exact_cpu=m68020 ;;
+ esac
+ fi
+ ;;
+
+
+rs6000-*-* | powerpc*-*-*)
+ # Enhancement: On MacOS the "machine" command prints for instance
+ # "ppc750". Interestingly on powerpc970-apple-darwin6.8.5 it prints
+ # "ppc970" where there's no actual #define for 970 from NXGetLocalArchInfo
+ # (as noted below). But the man page says the command is still "under
+ # development", so it doesn't seem wise to use it just yet, not while
+ # there's an alternative.
+ #
+ # Try to read the PVR. mfpvr is a protected instruction, NetBSD, MacOS
+ # and AIX don't allow it in user mode, but the Linux kernel does.
+ #
+ # Using explicit bytes for mfpvr avoids worrying about assembler syntax
+ # and underscores. "char"s are used instead of "int"s to avoid worrying
+ # whether sizeof(int)==4 or if it's the right endianness.
+ #
+ # Note this is no good on AIX, since a C function there is the address of
+ # a function descriptor, not actual code. But this doesn't matter since
+ # AIX doesn't allow mfpvr anyway.
+ #
+ eval $set_cc_for_build
+ cat >$dummy.c <<\EOF
+#include <stdio.h>
+struct {
+ int n; /* force 4-byte alignment */
+ char a[8];
+} getpvr = {
+ 0,
+ {
+ 0x7c, 0x7f, 0x42, 0xa6, /* mfpvr r3 */
+ 0x4e, 0x80, 0x00, 0x20, /* blr */
+ }
+};
+int
+main ()
+{
+ unsigned (*fun)();
+ unsigned pvr;
+
+ /* a separate "fun" variable is necessary for gcc 2.95.2 on MacOS,
+ it gets a compiler error on a combined cast and call */
+ fun = (unsigned (*)()) getpvr.a;
+ pvr = (*fun) ();
+
+ switch (pvr >> 16) {
+ case 0x0001: puts ("powerpc601"); break;
+ case 0x0003: puts ("powerpc603"); break;
+ case 0x0004: puts ("powerpc604"); break;
+ case 0x0006: puts ("powerpc603e"); break;
+ case 0x0007: puts ("powerpc603e"); break; /* 603ev */
+ case 0x0008: puts ("powerpc750"); break;
+ case 0x0009: puts ("powerpc604e"); break;
+ case 0x000a: puts ("powerpc604e"); break; /* 604ev5 */
+ case 0x000c: puts ("powerpc7400"); break;
+ case 0x0041: puts ("powerpc630"); break;
+ case 0x0050: puts ("powerpc860"); break;
+ case 0x8000: puts ("powerpc7450"); break;
+ case 0x8001: puts ("powerpc7455"); break;
+ case 0x8002: puts ("powerpc7457"); break;
+ case 0x8003: puts ("powerpc7447"); break; /* really 7447A */
+ case 0x800c: puts ("powerpc7410"); break;
+ }
+ return 0;
+}
+EOF
+ if ($CC_FOR_BUILD $dummy.c -o $dummy) >/dev/null 2>&1; then
+ # This style construct is needed on AIX 4.3 to suppress the SIGILL error
+ # from (*fun)(). Using $SHELL -c $dummy 2>/dev/null doesn't work.
+ { x=`$dummy`; } 2>/dev/null
+ if test -n "$x"; then
+ exact_cpu=$x
+ fi
+ fi
+
+ # Grep the linux kernel /proc/cpuinfo pseudo-file.
+ # Anything unrecognised is ignored, since of course we mustn't spit out
+ # a cpu type config.sub doesn't know.
+ if test -z "$exact_cpu" && test -f /proc/cpuinfo; then
+ x=`grep "^cpu[ ]" /proc/cpuinfo | head -n 1`
+ x=`echo $x | sed -n 's/^cpu[ ]*:[ ]*\([A-Za-z0-9]*\).*/\1/p'`
+ x=`echo $x | sed 's/PPC//'`
+ case $x in
+ 601) exact_cpu="power" ;;
+ 603ev) exact_cpu="powerpc603e" ;;
+ 604ev5) exact_cpu="powerpc604e" ;;
+ 970??) exact_cpu="powerpc970" ;;
+ 603 | 603e | 604 | 604e | 750 | 821 | 860)
+ exact_cpu="powerpc$x" ;;
+ POWER[4-9])
+ exact_cpu=`echo $x | sed "s;POWER;power;"` ;;
+ esac
+ fi
+
+ if test -z "$exact_cpu"; then
+ # On AIX, try looking at _system_configuration. This is present in
+ # version 4 at least.
+ cat >$dummy.c <<EOF
+#include <stdio.h>
+#include <sys/systemcfg.h>
+int
+main ()
+{
+ switch (_system_configuration.implementation) {
+ /* Old versions of AIX don't have all these constants,
+ use ifdef for safety. */
+#ifdef POWER_RS2
+ case POWER_RS2: puts ("power2"); break;
+#endif
+#ifdef POWER_601
+ case POWER_601: puts ("power"); break;
+#endif
+#ifdef POWER_603
+ case POWER_603: puts ("powerpc603"); break;
+#endif
+#ifdef POWER_604
+ case POWER_604: puts ("powerpc604"); break;
+#endif
+#ifdef POWER_620
+ case POWER_620: puts ("powerpc620"); break;
+#endif
+#ifdef POWER_630
+ case POWER_630: puts ("powerpc630"); break;
+#endif
+ /* Dunno what this is, leave it out for now.
+ case POWER_A35: puts ("powerpca35"); break;
+ */
+ /* This is waiting for a bit more info.
+ case POWER_RS64II: puts ("powerpcrs64ii"); break;
+ */
+#ifdef POWER_4
+ case POWER_4: puts ("power4"); break;
+#endif
+#ifdef POWER_5
+ case POWER_5: puts ("power5"); break;
+#endif
+#ifdef POWER_6
+ case POWER_6: puts ("power6"); break;
+#endif
+#ifdef POWER_7
+ case POWER_7: puts ("power7"); break;
+#endif
+ default:
+ if (_system_configuration.architecture == POWER_RS)
+ puts ("power");
+ else if (_system_configuration.width == 64)
+ puts ("powerpc64");
+ }
+ return 0;
+}
+EOF
+ if ($CC_FOR_BUILD $dummy.c -o $dummy) >/dev/null 2>&1; then
+ x=`$dummy`
+ if test -n "$x"; then
+ exact_cpu=$x
+ fi
+ fi
+ fi
+
+ if test -z "$exact_cpu"; then
+ # On MacOS X (or any Mach-O presumably), NXGetLocalArchInfo cpusubtype
+ # can tell us the exact cpu.
+ cat >$dummy.c <<EOF
+#include <stdio.h>
+#include <mach-o/arch.h>
+int
+main (void)
+{
+ const NXArchInfo *a = NXGetLocalArchInfo();
+ if (a->cputype == CPU_TYPE_POWERPC)
+ {
+ switch (a->cpusubtype) {
+ /* The following known to Darwin 1.3. */
+ case CPU_SUBTYPE_POWERPC_601: puts ("powerpc601"); break;
+ case CPU_SUBTYPE_POWERPC_602: puts ("powerpc602"); break;
+ case CPU_SUBTYPE_POWERPC_603: puts ("powerpc603"); break;
+ case CPU_SUBTYPE_POWERPC_603e: puts ("powerpc603e"); break;
+ case CPU_SUBTYPE_POWERPC_603ev: puts ("powerpc603e"); break;
+ case CPU_SUBTYPE_POWERPC_604: puts ("powerpc604"); break;
+ case CPU_SUBTYPE_POWERPC_604e: puts ("powerpc604e"); break;
+ case CPU_SUBTYPE_POWERPC_620: puts ("powerpc620"); break;
+ case CPU_SUBTYPE_POWERPC_750: puts ("powerpc750"); break;
+ case CPU_SUBTYPE_POWERPC_7400: puts ("powerpc7400"); break;
+ case CPU_SUBTYPE_POWERPC_7450: puts ("powerpc7450"); break;
+ /* Darwin 6.8.5 doesn't define the following */
+ case 0x8001: puts ("powerpc7455"); break;
+ case 0x8002: puts ("powerpc7457"); break;
+ case 0x8003: puts ("powerpc7447"); break;
+ case 100: puts ("powerpc970"); break;
+ }
+ }
+ return 0;
+}
+EOF
+ if ($CC_FOR_BUILD $dummy.c -o $dummy) >/dev/null 2>&1; then
+ x=`$dummy`
+ if test -n "$x"; then
+ exact_cpu=$x
+ fi
+ fi
+ fi
+ ;;
+
+sparc-*-* | sparc64-*-*)
+ # If we can recognise an actual v7 then $exact_cpu is set to "sparc" so as
+ # to short-circuit subsequent tests.
+
+ # Grep the linux kernel /proc/cpuinfo pseudo-file.
+ # A typical line is "cpu\t\t: TI UltraSparc II (BlackBird)"
+ # See arch/sparc/kernel/cpu.c and arch/sparc64/kernel/cpu.c.
+ #
+ if test -f /proc/cpuinfo; then
+ if grep 'cpu.*Cypress' /proc/cpuinfo >/dev/null; then
+ exact_cpu="sparc" # ie. v7
+ elif grep 'cpu.*Power-UP' /proc/cpuinfo >/dev/null; then
+ exact_cpu="sparc" # ie. v7
+ elif grep 'cpu.*HyperSparc' /proc/cpuinfo >/dev/null; then
+ exact_cpu="sparcv8"
+ elif grep 'cpu.*SuperSparc' /proc/cpuinfo >/dev/null; then
+ exact_cpu="supersparc"
+ elif grep 'cpu.*MicroSparc' /proc/cpuinfo >/dev/null; then
+ exact_cpu="microsparc"
+ elif grep 'cpu.*MB86904' /proc/cpuinfo >/dev/null; then
+ # actually MicroSPARC-II
+ exact_cpu=microsparc
+ elif grep 'cpu.*UltraSparc T4' /proc/cpuinfo >/dev/null; then
+ exact_cpu="ultrasparct4"
+ elif grep 'cpu.*UltraSparc T3' /proc/cpuinfo >/dev/null; then
+ exact_cpu="ultrasparct3"
+ elif grep 'cpu.*UltraSparc T2' /proc/cpuinfo >/dev/null; then
+ exact_cpu="ultrasparct2"
+ elif grep 'cpu.*UltraSparc T1' /proc/cpuinfo >/dev/null; then
+ exact_cpu="ultrasparct1"
+ elif grep 'cpu.*UltraSparc III' /proc/cpuinfo >/dev/null; then
+ exact_cpu="ultrasparc3"
+ elif grep 'cpu.*UltraSparc IIi' /proc/cpuinfo >/dev/null; then
+ exact_cpu="ultrasparc2i"
+ elif grep 'cpu.*UltraSparc II' /proc/cpuinfo >/dev/null; then
+ exact_cpu="ultrasparc2"
+ elif grep 'cpu.*UltraSparc' /proc/cpuinfo >/dev/null; then
+ exact_cpu="ultrasparc"
+ fi
+ fi
+
+ # Need to invoke this for setup of $dummy
+ eval $set_cc_for_build
+
+ # Grep the output from sysinfo on SunOS.
+ # sysinfo has been seen living in /bin or in /usr/kvm
+ # cpu0 is a "SuperSPARC Model 41 SPARCmodule" CPU
+ # cpu0 is a "75 MHz TI,TMS390Z55" CPU
+ #
+ if test -z "$exact_cpu"; then
+ for i in sysinfo /usr/kvm/sysinfo; do
+ if $SHELL -c $i 2>/dev/null >$dummy; then
+ if grep 'cpu0 is a "SuperSPARC' $dummy >/dev/null; then
+ exact_cpu=supersparc
+ break
+ elif grep 'cpu0 is a .*TMS390Z5.' $dummy >/dev/null; then
+ # TMS390Z50 and TMS390Z55
+ exact_cpu=supersparc
+ break
+ fi
+ fi
+ done
+ fi
+
+ # Grep the output from prtconf on Solaris.
+ # Use an explicit /usr/sbin, since that directory might not be in a normal
+ # user's path.
+ #
+ # SUNW,UltraSPARC (driver not attached)
+ # SUNW,UltraSPARC-II (driver not attached)
+ # SUNW,UltraSPARC-IIi (driver not attached)
+ # SUNW,UltraSPARC-III+ (driver not attached)
+ # Ross,RT625 (driver not attached)
+ # TI,TMS390Z50 (driver not attached)
+ #
+ # /usr/sbin/sysdef prints similar information, but includes all loadable
+ # cpu modules, not just the real cpu.
+ #
+ # We first try a plain prtconf, since that is known to work on older systems.
+ # But for newer T1 systems, that doesn't produce any useful output, we need
+ # "prtconf -vp" there.
+ #
+ for prtconfopt in "" "-vp"; do
+ if test -z "$exact_cpu"; then
+ if $SHELL -c "/usr/sbin/prtconf $prtconfopt" 2>/dev/null >$dummy; then
+ if grep 'SUNW,UltraSPARC-T3' $dummy >/dev/null; then
+ exact_cpu=ultrasparct3
+ elif grep 'SUNW,UltraSPARC-T2' $dummy >/dev/null; then
+ exact_cpu=ultrasparct2
+ elif grep 'SUNW,UltraSPARC-T1' $dummy >/dev/null; then
+ exact_cpu=ultrasparct1
+ elif grep 'SUNW,UltraSPARC-III' $dummy >/dev/null; then
+ exact_cpu=ultrasparc3
+ elif grep 'SUNW,UltraSPARC-IIi' $dummy >/dev/null; then
+ exact_cpu=ultrasparc2i
+ elif grep 'SUNW,UltraSPARC-II' $dummy >/dev/null; then
+ exact_cpu=ultrasparc2
+ elif grep 'SUNW,UltraSPARC' $dummy >/dev/null; then
+ exact_cpu=ultrasparc
+ elif grep 'Ross,RT62.' $dummy >/dev/null; then
+ # RT620, RT625, RT626 hypersparcs (v8).
+ exact_cpu=sparcv8
+ elif grep 'TI,TMS390Z5.' $dummy >/dev/null; then
+ # TMS390Z50 and TMS390Z55
+ exact_cpu=supersparc
+ elif grep 'TI,TMS390S10' $dummy >/dev/null; then
+ exact_cpu=microsparc
+ elif grep 'FMI,MB86904' $dummy >/dev/null; then
+ # actually MicroSPARC-II
+ exact_cpu=microsparc
+ fi
+ fi
+ fi
+ done
+
+ # Grep the output from sysctl hw.model on sparc or sparc64 *BSD.
+ # Use an explicit /sbin, since that directory might not be in a normal
+ # user's path. Example outputs,
+ #
+ # hw.model: Sun Microsystems UltraSparc-IIi
+ #
+ if test -z "$exact_cpu"; then
+ if $SHELL -c "/sbin/sysctl hw.model" 2>/dev/null >$dummy; then
+ if grep -i 'UltraSparc-T3' $dummy >/dev/null; then
+ exact_cpu=ultrasparct3
+ elif grep -i 'UltraSparc-T2' $dummy >/dev/null; then
+ exact_cpu=ultrasparct2
+ elif grep -i 'UltraSparc-T1' $dummy >/dev/null; then
+ exact_cpu=ultrasparct1
+ elif grep -i 'UltraSparc-III' $dummy >/dev/null; then
+ exact_cpu=ultrasparc3
+ elif grep -i 'UltraSparc-IIi' $dummy >/dev/null; then
+ exact_cpu=ultrasparc2i
+ elif grep -i 'UltraSparc-II' $dummy >/dev/null; then
+ exact_cpu=ultrasparc2
+ elif grep -i 'UltraSparc' $dummy >/dev/null; then
+ exact_cpu=ultrasparc
+ elif grep 'TMS390Z5.' $dummy >/dev/null; then
+ # TMS390Z50 and TMS390Z55
+ exact_cpu=supersparc
+ elif grep 'TMS390S10' $dummy >/dev/null; then
+ exact_cpu=microsparc
+ elif grep 'MB86904' $dummy >/dev/null; then
+ # actually MicroSPARC-II
+ exact_cpu=microsparc
+ elif grep 'MB86907' $dummy >/dev/null; then
+ exact_cpu=turbosparc
+ fi
+ fi
+ fi
+
+ # sun4m and sun4d are v8s of some sort, sun4u is a v9 of some sort
+ #
+ if test -z "$exact_cpu"; then
+ case `uname -m` in
+ sun4[md]) exact_cpu=sparcv8 ;;
+ sun4u) exact_cpu=sparcv9 ;;
+ esac
+ fi
+ ;;
+
+
+# Recognise x86 processors using a tricky cpuid with 4 arguments, repeating
+# arguments; for x86-64 we effectively pass the 1st in rdx and the 2nd in rcx.
+# This allows the same asm to work for both standard and Windoze calling
+# conventions.
+
+i?86-*-* | amd64-*-* | x86_64-*-*)
+ eval $set_cc_for_build
+
+ cat <<EOF >$dummy.c
+#include <string.h>
+#include <stdio.h>
+#define CPUID(a,b) cpuid(b,a,a,b)
+#if __cplusplus
+extern "C"
+#endif
+unsigned int cpuid (int, char *, char *, int);
+int
+main ()
+{
+ char vendor_string[13];
+ char dummy_string[12];
+ long fms;
+ int family, model, stepping;
+ const char *modelstr;
+ int cpu_64bit = 0;
+ int cpuid_64bit;
+
+ CPUID (vendor_string, 0);
+ vendor_string[12] = 0;
+
+ fms = CPUID (dummy_string, 1);
+
+ family = ((fms >> 8) & 0xf) + ((fms >> 20) & 0xff);
+ model = ((fms >> 4) & 0xf) + ((fms >> 12) & 0xf0);
+ stepping = fms & 0xf;
+
+ modelstr = "$guess_cpu";
+
+ /**************************************************/
+ /*** WARNING: keep this list in sync with fat.c ***/
+ /**************************************************/
+ if (strcmp (vendor_string, "GenuineIntel") == 0)
+ {
+ switch (family)
+ {
+ case 5:
+ if (model <= 2) modelstr = "pentium";
+ else if (model >= 4) modelstr = "pentiummmx";
+ break;
+ case 6:
+ if (model <= 1) modelstr = "pentiumpro";
+ else if (model <= 6) modelstr = "pentium2";
+ else if (model <= 8) modelstr = "pentium3";
+ else if (model <= 9) modelstr = "pentiumm";
+ else if (model <= 0x0c) modelstr = "pentium3";
+ else if (model <= 0x0e) modelstr = "pentiumm";
+ else if (model <= 0x19) cpu_64bit = 1, modelstr = "core2";
+ else if (model == 0x1a) cpu_64bit = 1, modelstr = "coreinhm"; /* NHM Gainestown */
+ else if (model == 0x1c) cpu_64bit = 1, modelstr = "atom"; /* Silverthorne */
+ else if (model == 0x1d) cpu_64bit = 1, modelstr = "core2"; /* PNR Dunnington */
+ else if (model == 0x1e) cpu_64bit = 1, modelstr = "coreinhm"; /* NHM Lynnfield/Jasper */
+ else if (model == 0x25) cpu_64bit = 1, modelstr = "coreiwsm"; /* WSM Clarkdale/Arrandale */
+ else if (model == 0x26) cpu_64bit = 1, modelstr = "atom"; /* Lincroft */
+ else if (model == 0x27) cpu_64bit = 1, modelstr = "atom"; /* Saltwell */
+ else if (model == 0x2a) cpu_64bit = 1, modelstr = "coreisbr"; /* SB */
+ else if (model == 0x2c) cpu_64bit = 1, modelstr = "coreiwsm"; /* WSM Gulftown */
+ else if (model == 0x2d) cpu_64bit = 1, modelstr = "coreisbr"; /* SBC-EP */
+ else if (model == 0x2e) cpu_64bit = 1, modelstr = "coreinhm"; /* NHM Beckton */
+ else if (model == 0x2f) cpu_64bit = 1, modelstr = "coreiwsm"; /* WSM Eagleton */
+ else if (model == 0x36) cpu_64bit = 1, modelstr = "atom"; /* Cedarview/Saltwell */
+ else if (model == 0x37) cpu_64bit = 1, modelstr = "coreinhm"; /* Atom Silvermont */
+ else if (model == 0x3a) cpu_64bit = 1, modelstr = "coreisbr"; /* IBR */
+ else if (model == 0x3c) cpu_64bit = 1, modelstr = "coreihwl"; /* Haswell client */
+ else if (model == 0x3d) cpu_64bit = 1, modelstr = "coreibwl"; /* Broadwell */
+ else if (model == 0x3e) cpu_64bit = 1, modelstr = "coreisbr"; /* Ivytown */
+ else if (model == 0x3f) cpu_64bit = 1, modelstr = "coreihwl"; /* Haswell server */
+ else if (model == 0x45) cpu_64bit = 1, modelstr = "coreihwl"; /* Haswell ULT */
+ else if (model == 0x46) cpu_64bit = 1, modelstr = "coreihwl"; /* Crystal Well */
+ else if (model == 0x4d) cpu_64bit = 1, modelstr = "coreinhm"; /* Silvermont/Avoton */
+ else if (model == 0x4f) cpu_64bit = 1, modelstr = "coreibwl"; /* Broadwell server */
+ else if (model == 0x56) cpu_64bit = 1, modelstr = "coreibwl"; /* Broadwell microserver */
+ else cpu_64bit = 1, modelstr = "corei"; /* default */
+
+ if (strcmp (modelstr, "coreihwl") == 0)
+ {
+ /* Some Haswells lack BMI2. Let them appear as Sandybridges for
+ now. */
+ CPUID (dummy_string, 7);
+ if ((dummy_string[0 + 8 / 8] & (1 << (8 % 8))) == 0)
+ modelstr = "coreisbr";
+ }
+
+ break;
+ case 15:
+ cpu_64bit = 1, modelstr = "pentium4";
+ break;
+ }
+ }
+ else if (strcmp (vendor_string, "AuthenticAMD") == 0)
+ {
+ switch (family)
+ {
+ case 5:
+ if (model <= 3) modelstr = "k5";
+ else if (model <= 7) modelstr = "k6";
+ else if (model == 8) modelstr = "k62";
+ else if (model == 9) modelstr = "k63";
+ else if (model == 10) modelstr = "geode";
+ else if (model == 13) modelstr = "k63";
+ break;
+ case 6:
+ modelstr = "athlon";
+ break;
+ case 15: /* K8, K9 */
+ cpu_64bit = 1, modelstr = "k8";
+ break;
+ case 16: /* K10 */
+ cpu_64bit = 1, modelstr = "k10";
+ break;
+ case 17: /* Hybrid k8/k10, claim k8 */
+ cpu_64bit = 1, modelstr = "k8";
+ break;
+ case 18: /* Llano, uses K10 core */
+ cpu_64bit = 1, modelstr = "k10";
+ break;
+ case 19: /* AMD Internal, assume future K10 */
+ cpu_64bit = 1, modelstr = "k10";
+ break;
+ case 20: /* Bobcat */
+ cpu_64bit = 1, modelstr = "bobcat";
+ break;
+ case 21: /* Bulldozer */
+ cpu_64bit = 1;
+ if (model <= 1)
+ modelstr = "bulldozer";
+ else if (model < 0x20) /* really 2, [0x10-0x20) */
+ modelstr = "piledriver";
+ else if (model < 0x40) /* really [0x30-0x40) */
+ modelstr = "steamroller";
+ else /* really [0x60-0x70) */
+ modelstr = "excavator";
+ break;
+ case 22: /* Jaguar, an improved bobcat */
+ cpu_64bit = 1, modelstr = "jaguar";
+ break;
+ }
+ }
+ else if (strcmp (vendor_string, "CyrixInstead") == 0)
+ {
+ /* Should recognize Cyrix' processors too. */
+ }
+ else if (strcmp (vendor_string, "CentaurHauls") == 0)
+ {
+ switch (family)
+ {
+ case 6:
+ if (model < 9) modelstr = "viac3";
+ else if (model < 15) modelstr = "viac32";
+ else cpu_64bit = 1, modelstr = "nano";
+ break;
+ }
+ }
+
+ CPUID (dummy_string, 0x80000001);
+ cpuid_64bit = (dummy_string[7] >> 5) & 1;
+
+ /* If our cpuid-based CPU identification thinks this is a 32-bit CPU but
+ cpuid claims AMD64 capabilities, then revert to the generic "x86_64".
+ This is of course wrong, but it can happen in some emulators, so this
+ workaround allows for successful 64-bit builds. */
+ if (cpuid_64bit && ! cpu_64bit)
+ modelstr = "x86_64";
+
+ printf ("%s", modelstr);
+ return 0;
+}
+EOF
+
+# The rcx/ecx zeroing here and in the variant below is needed for the BMI2
+# check.
+
+ cat <<EOF >${dummy}0.s
+ .globl cpuid
+ .globl _cpuid
+cpuid:
+_cpuid:
+ push %rbx
+ mov %rdx, %r8
+ mov %ecx, %eax
+ xor %ecx, %ecx
+ .byte 0x0f
+ .byte 0xa2
+ mov %ebx, (%r8)
+ mov %edx, 4(%r8)
+ mov %ecx, 8(%r8)
+ pop %rbx
+ ret
+EOF
+
+ if ($CC_FOR_BUILD ${dummy}0.s $dummy.c -o $dummy) >/dev/null 2>&1; then
+ # On 80386 and early 80486 cpuid is not available and will result in a
+ # SIGILL message, hence 2>/dev/null.
+ #
+ # On i386-unknown-freebsd4.9, "/bin/sh -c ./dummy" seems to send an
+ # "Illegal instruction (core dumped)" message to stdout, so we test $?
+ # to check if the program run was successful.
+ #
+ x=`$SHELL -c $dummy 2>/dev/null`
+ if test $? = 0 && test -n "$x"; then
+ exact_cpu=$x
+ fi
+ fi
+
+ cat <<EOF >${dummy}0.s
+ .globl cpuid
+ .globl _cpuid
+cpuid:
+_cpuid:
+ pushl %esi
+ pushl %ebx
+ movl 24(%esp),%eax
+ xor %ecx, %ecx
+ .byte 0x0f
+ .byte 0xa2
+ movl 20(%esp),%esi
+ movl %ebx,(%esi)
+ movl %edx,4(%esi)
+ movl %ecx,8(%esi)
+ popl %ebx
+ popl %esi
+ ret
+EOF
+
+ if test -z "$exact_cpu"; then
+ if ($CC_FOR_BUILD ${dummy}0.s $dummy.c -o $dummy) >/dev/null 2>&1; then
+ # On 80386 and early 80486 cpuid is not available and will result in a
+ # SIGILL message, hence 2>/dev/null.
+ #
+ # On i386-unknown-freebsd4.9, "/bin/sh -c ./dummy" seems to send an
+ # "Illegal instruction (core dumped)" message to stdout, so we test $?
+ # to check if the program run was successful.
+ #
+ x=`$SHELL -c $dummy 2>/dev/null`
+ if test $? = 0 && test -n "$x"; then
+ exact_cpu=$x
+ fi
+ fi
+ fi
+
+ # We need to remove some .o files here since lame C compilers
+ # generate these even when not asked.
+ ;;
+
+s390*-*-*)
+ model=`grep "^processor 0: version =" /proc/cpuinfo | sed -e 's/.*machine = //'`
+ case $model in
+ 2064 | 2066) zcpu="z900" ;;
+ 2084 | 2086) zcpu="z990" ;;
+ 2094 | 2096) zcpu="z9" ;;
+ 2097 | 2098) zcpu="z10" ;;
+ 2817 | 2818 | *) zcpu="z196" ;;
+ esac
+ case "$guess_full" in
+ s390x-*-*) exact_cpu=${zcpu} ;;
+ s390-*-*) exact_cpu=${zcpu}esa ;;
+ esac
+ ;;
+
+esac
+
+
+
+# -------------------------------------------------------------------------
+# Use an exact cpu, if possible
+
+if test -n "$exact_cpu"; then
+ echo "$exact_cpu$guess_rest"
+else
+ echo "$guess_full"
+fi
+exit 0
+
+
+
+# Local variables:
+# fill-column: 76
+# End: