release/src/router/gmp/config.guess

   1 #! /bin/sh
   2 #
   3 # GMP config.guess wrapper.
   4
   5
   6 # Copyright 2000-2006, 2008, 2011-2014 Free Software Foundation, Inc.
   7 #
   8 #  This file is part of the GNU MP Library.
   9 #
  10 #  The GNU MP Library is free software; you can redistribute it and/or modify
  11 #  it under the terms of either:
  12 #
  13 #    * the GNU Lesser General Public License as published by the Free
  14 #      Software Foundation; either version 3 of the License, or (at your
  15 #      option) any later version.
  16 #
  17 #  or
  18 #
  19 #    * the GNU General Public License as published by the Free Software
  20 #      Foundation; either version 2 of the License, or (at your option) any
  21 #      later version.
  22 #
  23 #  or both in parallel, as here.
  24 #
  25 #  The GNU MP Library is distributed in the hope that it will be useful, but
  26 #  WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  27 #  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  28 #  for more details.
  29 #
  30 #  You should have received copies of the GNU General Public License and the
  31 #  GNU Lesser General Public License along with the GNU MP Library.  If not,
  32 #  see https://www.gnu.org/licenses/.
  33
  34
  35 # Usage: config.guess
  36 #
  37 # Print the host system CPU-VENDOR-OS.
  38 #
  39 # configfsf.guess is run and its guess then sharpened up to take advantage
  40 # of the finer grained CPU types that GMP knows.
  41
  42
  43 # Expect to find configfsf.guess in the same directory as this config.guess
  44 configfsf_guess="`echo \"$0\" | sed 's/config.guess$/configfsf.guess/'`"
  45 if test "$configfsf_guess" = "$0"; then
  46   echo "Cannot derive configfsf.guess from $0" 1>&2
  47   exit 1
  48 fi
  49 if test -f "$configfsf_guess"; then
  50   :
  51 else
  52   echo "$configfsf_guess not found" 1>&2
  53   exit 1
  54 fi
  55
  56 # Setup a $SHELL with which to run configfsf.guess, using the same
  57 # $CONFIG_SHELL or /bin/sh as autoconf does when running config.guess
  58 SHELL=${CONFIG_SHELL-/bin/sh}
  59
  60 # Identify ourselves on --version, --help or errors
  61 if test $# != 0; then
  62   echo "(GNU MP wrapped config.guess)"
  63   $SHELL $configfsf_guess "$@"
  64   exit 1
  65 fi
  66
  67 guess_full=`$SHELL $configfsf_guess`
  68 if test $? != 0; then
  69   exit 1
  70 fi
  71
  72 guess_cpu=`echo "$guess_full" | sed 's/-.*$//'`
  73 guess_rest=`echo "$guess_full" | sed 's/^[^-]*//'`
  74 exact_cpu=
  75
  76
  77 # -------------------------------------------------------------------------
  78 # The following should look at the current guess and probe the system to
  79 # establish a better guess in exact_cpu.  Leave exact_cpu empty if probes
  80 # can't be done, or don't work.
  81 #
  82 # When a number of probes are done, test -z "$exact_cpu" can be used instead
  83 # of putting each probe under an "else" of the preceeding.  That can stop
  84 # the code getting horribly nested and marching off the right side of the
  85 # screen.
  86
  87 # Note that when a compile-and-link is done in one step we need to remove .o
  88 # files, since lame C compilers generate these even when not asked.
  89 #
  90
  91 # CC_FOR_BUILD -- compiler used by this script. Note that the use of a
  92 # compiler to aid in system detection is discouraged as it requires
  93 # temporary files to be created and, as you can see below, it is a
  94 # headache to deal with in a portable fashion.
  95
  96 # Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still
  97 # use `HOST_CC' if defined, but it is deprecated.
  98
  99 # Portable tmp directory creation inspired by the Autoconf team.
 100
 101 set_cc_for_build='
 102 trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ;
 103 trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ;
 104 : ${TMPDIR=/tmp} ;
 105  { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } ||
 106  { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } ||
 107  { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } ||
 108  { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ;
 109 dummy=$tmp/dummy ;
 110 tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy $dummy.core ${dummy}0.s" ;
 111 case $CC_FOR_BUILD,$HOST_CC,$CC in
 112  ,,)    echo "int x;" > $dummy.c ;
 113         for c in cc gcc c89 c99 ; do
 114           if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then
 115              CC_FOR_BUILD="$c"; break ;
 116           fi ;
 117         done ;
 118         if test x"$CC_FOR_BUILD" = x ; then
 119           CC_FOR_BUILD=no_compiler_found ;
 120         fi
 121         ;;
 122  ,,*)   CC_FOR_BUILD=$CC ;;
 123  ,*,*)  CC_FOR_BUILD=$HOST_CC ;;
 124 esac ; set_cc_for_build= ;'
 125
 126
 127 case "$guess_full" in
 128
 129 alpha-*-*)
 130   eval $set_cc_for_build
 131   # configfsf.guess detects exact alpha cpu types for OSF and GNU/Linux, but
 132   # not for *BSD and other systems.  We try to get an exact type for any
 133   # plain "alpha" it leaves.
 134   #
 135   # configfsf.guess used to have a block of code not unlike this, but these
 136   # days does its thing with Linux kernel /proc/cpuinfo or OSF psrinfo.
 137   #
 138   cat <<EOF >${dummy}0.s
 139         .data
 140 Lformat:
 141         .byte 37,100,45,37,120,10,0     # "%d-%x\n"
 142         .text
 143         .globl main
 144         .align 4
 145         .ent main
 146 main:
 147         .frame \$30,16,\$26,0
 148         ldgp \$29,0(\$27)
 149         .prologue 1
 150         .long 0x47e03d91 # implver \$17
 151         lda \$2,-1
 152         .long 0x47e20c21 # amask \$2,\$1
 153         lda \$16,Lformat
 154         not \$1,\$18
 155         jsr \$26,printf
 156         ldgp \$29,0(\$26)
 157         mov 0,\$16
 158         jsr \$26,exit
 159         .end main
 160 EOF
 161   $CC_FOR_BUILD ${dummy}0.s -o $dummy 2>/dev/null
 162   if test "$?" = 0 ; then
 163     case `$dummy` in
 164     0-0)        exact_cpu=alpha      ;;
 165     1-0)        exact_cpu=alphaev5   ;;
 166     1-1)        exact_cpu=alphaev56  ;;
 167     1-101)      exact_cpu=alphapca56 ;;
 168     2-303)      exact_cpu=alphaev6   ;;
 169     2-307)      exact_cpu=alphaev67  ;;
 170     2-1307)     exact_cpu=alphaev68  ;;
 171     esac
 172   fi
 173   ;;
 174
 175 arm*-*-*)
 176   cpu_code=`sed -n 's/^CPU part.*\(0x.*\)$/\1/p' /proc/cpuinfo 2>/dev/null`
 177   case "$cpu_code" in
 178       0xa10 | 0xa11 | 0xb11)                    # v4 strongarm/sa1100
 179                 exact_cpu="armsa1";;
 180       0x915 | 0x925 | \
 181       0x920 | 0x922 | 0x940)                    # v4
 182                 exact_cpu="arm9tdmi";;
 183       0x210 | 0x290 | 0x2d0 | \
 184       0x212 | 0x292 | 0x2d2 | \
 185       0x411)    exact_cpu="armxscale";;         # v5 pxa2xx
 186       0x926 | 0x946 | 0x966 | 0x968)            # v5te/v5tej
 187                 exact_cpu="arm9te";;
 188       0xa20 | 0xa22 | 0xa26)                    # v5te
 189                 exact_cpu="arm10";;
 190       0xb02)    exact_cpu="arm11mpcore";;       # v6
 191       0xb36)    exact_cpu="arm1136";;           # v6
 192       0xb56)    exact_cpu="arm1156";;           # v6t2
 193       0xb76)    exact_cpu="arm1176";;           # v6
 194       0xc05)    exact_cpu="armcortexa5";;       # v7a
 195       0xc07)    exact_cpu="armcortexa7";;       # v7a
 196       0xc08)    exact_cpu="armcortexa8";;       # v7a
 197       0xc09)    exact_cpu="armcortexa9";;       # v7a
 198       0xc0f)    exact_cpu="armcortexa15";;      # v7a
 199       0xc14)    exact_cpu="armcortexr4";;       # v7r
 200       0xc15)    exact_cpu="armcortexr5";;       # v7r
 201       0xc23)    exact_cpu="armcortexm3";;       # v7m
 202   esac
 203   exact_cpu="${exact_cpu}`sed -n 's;^Features.*\(neon\).*;\1;p' /proc/cpuinfo 2>/dev/null`"
 204   ;;
 205
 206 ia64*-*-*)
 207   eval $set_cc_for_build
 208   # CPUID[3] bits 24 to 31 is the processor family.  itanium2 is documented
 209   # as 0x1f, plain itanium has been seen returning 0x07 on two systems, but
 210   # haven't found any documentation on it as such.
 211   #
 212   # Defining both getcpuid and _getcpuid lets us ignore whether the system
 213   # expects underscores or not.
 214   #
 215   # "unsigned long long" is always 64 bits, in fact on hpux in ilp32 mode
 216   # (which is the default there), it's the only 64-bit type.
 217   #
 218   cat >${dummy}0.s <<EOF
 219         .text
 220         .global _getcpuid
 221         .proc   _getcpuid
 222 _getcpuid:
 223         mov     r8 = CPUID[r32] ;;
 224         br.ret.sptk.many rp ;;
 225         .endp   _getcpuid
 226         .global getcpuid
 227         .proc   getcpuid
 228 getcpuid:
 229         mov     r8 = CPUID[r32] ;;
 230         br.ret.sptk.many rp ;;
 231         .endp   getcpuid
 232 EOF
 233   cat >$dummy.c <<EOF
 234 #include <stdio.h>
 235 unsigned long long getcpuid ();
 236 int
 237 main ()
 238 {
 239   if (getcpuid(0LL) == 0x49656E69756E6547LL && getcpuid(1LL) == 0x6C65746ELL)
 240     {
 241       /* "GenuineIntel" */
 242       switch ((getcpuid(3LL) >> 24) & 0xFF) {
 243       case 0x07: puts ("itanium");  break;
 244       case 0x1F: puts ("itanium2"); break; /* McKinley, Madison */
 245       case 0x20: puts ("itanium2"); break; /* Montecito */
 246       }
 247     }
 248   return 0;
 249 }
 250 EOF
 251   if $CC_FOR_BUILD ${dummy}0.s $dummy.c -o $dummy >/dev/null 2>&1; then
 252     exact_cpu=`$dummy`
 253   fi
 254   ;;
 255
 256 mips-*-irix[6789]*)
 257   # IRIX 6 and up always has a 64-bit mips cpu
 258   exact_cpu=mips64
 259   ;;
 260
 261 m68k-*-*)
 262   eval $set_cc_for_build
 263   # NetBSD (and presumably other *BSD) "sysctl hw.model" gives for example
 264   #   hw.model = Apple Macintosh Quadra 610  (68040)
 265   exact_cpu=`(sysctl hw.model) 2>/dev/null | sed -n 's/^.*\(680[012346]0\).*$/m\1/p'`
 266   if test -z "$exact_cpu"; then
 267     # Linux kernel 2.2 gives for example "CPU: 68020" (tabs in between).
 268     exact_cpu=`sed -n 's/^CPU:.*\(680[012346]0\).*$/m\1/p' /proc/cpuinfo 2>/dev/null`
 269   fi
 270   if test -z "$exact_cpu"; then
 271     # Try: movel #0,%d0; rts
 272     # This is to check the compiler and our asm code works etc, before
 273     # assuming failures below indicate cpu characteristics.
 274     # .byte is used to avoid problems with assembler syntax variations.
 275     # For testing, provoke failures by adding "illegal" possibly as
 276     # ".byte 0x4A, 0xFC"
 277     cat >${dummy}0.s <<EOF
 278         .text
 279         .globl main
 280         .globl _main
 281 main:
 282 _main:
 283         .byte   0x70, 0x00
 284         .byte   0x4e, 0x75
 285 EOF
 286
 287     if ($CC_FOR_BUILD ${dummy}0.s -o $dummy && $dummy) >/dev/null 2>&1; then
 288
 289       # $SHELL -c is used to execute $dummy below, since ($dummy)
 290       # 2>/dev/null still prints the SIGILL message on some shells.
 291       #
 292         # Try: movel #0,%d0
 293         #      rtd #0
 294         cat >${dummy}0.s <<EOF
 295         .text
 296         .globl main
 297         .globl _main
 298 main:
 299 _main:
 300         .byte   0x70, 0x00
 301         .byte   0x4e, 0x74, 0x00, 0x00
 302 EOF
 303         if $CC_FOR_BUILD ${dummy}0.s -o $dummy >/dev/null 2>&1; then
 304           $SHELL -c $dummy >/dev/null 2>&1
 305           if test $? != 0; then
 306             exact_cpu=m68000    # because rtd didn't work
 307           fi
 308         fi
 309       #
 310
 311       if test -z "$exact_cpu"; then
 312         # Try: trapf
 313         #      movel #0,%d0
 314         #      rts
 315         # Another possibility for identifying 68000 and 68010 is the
 316         # different value stored by "movem a0,(a0)+"
 317         cat >${dummy}0.s <<EOF
 318         .text
 319         .globl main
 320         .globl _main
 321 main:
 322 _main:
 323         .byte   0x51, 0xFC
 324         .byte   0x70, 0x00
 325         .byte   0x4e, 0x75
 326 EOF
 327         if $CC_FOR_BUILD ${dummy}0.s -o $dummy >/dev/null 2>&1; then
 328           $SHELL -c $dummy >/dev/null 2>&1
 329           if test $? != 0; then
 330             exact_cpu=m68010    # because trapf didn't work
 331           fi
 332         fi
 333       fi
 334
 335       if test -z "$exact_cpu"; then
 336         # Try: bfffo %d1{0:31},%d0
 337         #      movel #0,%d0
 338         #      rts
 339         cat >${dummy}0.s <<EOF
 340         .text
 341         .globl main
 342         .globl _main
 343 main:
 344 _main:
 345         .byte   0xED, 0xC1, 0x00, 0x1F
 346         .byte   0x70, 0x00
 347         .byte   0x4e, 0x75
 348 EOF
 349         if $CC_FOR_BUILD ${dummy}0.s -o $dummy >/dev/null 2>&1; then
 350           $SHELL -c $dummy >/dev/null 2>&1
 351           if test $? != 0; then
 352             exact_cpu=m68360  # cpu32, because bfffo didn't work
 353           fi
 354         fi
 355       fi
 356
 357       if test -z "$exact_cpu"; then
 358         # FIXME: Now we know 68020 or up, but how to detect 030, 040 and 060?
 359         exact_cpu=m68020
 360       fi
 361     fi
 362   fi
 363   if test -z "$exact_cpu"; then
 364     case "$guess_full" in
 365       *-*-next* | *-*-openstep*)  # NeXTs are 68020 or better
 366         exact_cpu=m68020 ;;
 367     esac
 368   fi
 369   ;;
 370
 371
 372 rs6000-*-* | powerpc*-*-*)
 373   # Enhancement: On MacOS the "machine" command prints for instance
 374   # "ppc750".  Interestingly on powerpc970-apple-darwin6.8.5 it prints
 375   # "ppc970" where there's no actual #define for 970 from NXGetLocalArchInfo
 376   # (as noted below).  But the man page says the command is still "under
 377   # development", so it doesn't seem wise to use it just yet, not while
 378   # there's an alternative.
 379   #
 380   # Try to read the PVR.  mfpvr is a protected instruction, NetBSD, MacOS
 381   # and AIX don't allow it in user mode, but the Linux kernel does.
 382   #
 383   # Using explicit bytes for mfpvr avoids worrying about assembler syntax
 384   # and underscores.  "char"s are used instead of "int"s to avoid worrying
 385   # whether sizeof(int)==4 or if it's the right endianness.
 386   #
 387   # Note this is no good on AIX, since a C function there is the address of
 388   # a function descriptor, not actual code.  But this doesn't matter since
 389   # AIX doesn't allow mfpvr anyway.
 390   #
 391   eval $set_cc_for_build
 392   cat >$dummy.c <<\EOF
 393 #include <stdio.h>
 394 struct {
 395   int   n;  /* force 4-byte alignment */
 396   char  a[8];
 397 } getpvr = {
 398   0,
 399   {
 400     0x7c, 0x7f, 0x42, 0xa6,  /* mfpvr r3 */
 401     0x4e, 0x80, 0x00, 0x20,  /* blr      */
 402   }
 403 };
 404 int
 405 main ()
 406 {
 407   unsigned  (*fun)();
 408   unsigned  pvr;
 409
 410   /* a separate "fun" variable is necessary for gcc 2.95.2 on MacOS,
 411      it gets a compiler error on a combined cast and call */
 412   fun = (unsigned (*)()) getpvr.a;
 413   pvr = (*fun) ();
 414
 415   switch (pvr >> 16) {
 416   case 0x0001: puts ("powerpc601");  break;
 417   case 0x0003: puts ("powerpc603");  break;
 418   case 0x0004: puts ("powerpc604");  break;
 419   case 0x0006: puts ("powerpc603e"); break;
 420   case 0x0007: puts ("powerpc603e"); break;  /* 603ev */
 421   case 0x0008: puts ("powerpc750");  break;
 422   case 0x0009: puts ("powerpc604e"); break;
 423   case 0x000a: puts ("powerpc604e"); break;  /* 604ev5 */
 424   case 0x000c: puts ("powerpc7400"); break;
 425   case 0x0041: puts ("powerpc630");  break;
 426   case 0x0050: puts ("powerpc860");  break;
 427   case 0x8000: puts ("powerpc7450"); break;
 428   case 0x8001: puts ("powerpc7455"); break;
 429   case 0x8002: puts ("powerpc7457"); break;
 430   case 0x8003: puts ("powerpc7447"); break; /* really 7447A */
 431   case 0x800c: puts ("powerpc7410"); break;
 432   }
 433   return 0;
 434 }
 435 EOF
 436   if ($CC_FOR_BUILD $dummy.c -o $dummy) >/dev/null 2>&1; then
 437     # This style construct is needed on AIX 4.3 to suppress the SIGILL error
 438     # from (*fun)().  Using $SHELL -c $dummy 2>/dev/null doesn't work.
 439     { x=`$dummy`; } 2>/dev/null
 440     if test -n "$x"; then
 441       exact_cpu=$x
 442     fi
 443   fi
 444
 445   # Grep the linux kernel /proc/cpuinfo pseudo-file.
 446   # Anything unrecognised is ignored, since of course we mustn't spit out
 447   # a cpu type config.sub doesn't know.
 448   if test -z "$exact_cpu" && test -f /proc/cpuinfo; then
 449     x=`grep "^cpu[      ]" /proc/cpuinfo | head -n 1`
 450     x=`echo $x | sed -n 's/^cpu[        ]*:[    ]*\([A-Za-z0-9]*\).*/\1/p'`
 451     x=`echo $x | sed 's/PPC//'`
 452     case $x in
 453       601)     exact_cpu="power" ;;
 454       603ev)   exact_cpu="powerpc603e" ;;
 455       604ev5)  exact_cpu="powerpc604e" ;;
 456       970??)   exact_cpu="powerpc970" ;;
 457       603 | 603e | 604 | 604e | 750 | 821 | 860)
 458         exact_cpu="powerpc$x" ;;
 459       POWER[4-9])
 460         exact_cpu=`echo $x | sed "s;POWER;power;"` ;;
 461     esac
 462   fi
 463
 464   if test -z "$exact_cpu"; then
 465     # On AIX, try looking at _system_configuration.  This is present in
 466     # version 4 at least.
 467     cat >$dummy.c <<EOF
 468 #include <stdio.h>
 469 #include <sys/systemcfg.h>
 470 int
 471 main ()
 472 {
 473   switch (_system_configuration.implementation) {
 474   /* Old versions of AIX don't have all these constants,
 475      use ifdef for safety. */
 476 #ifdef POWER_RS2
 477   case POWER_RS2:    puts ("power2");     break;
 478 #endif
 479 #ifdef POWER_601
 480   case POWER_601:    puts ("power");      break;
 481 #endif
 482 #ifdef POWER_603
 483   case POWER_603:    puts ("powerpc603"); break;
 484 #endif
 485 #ifdef POWER_604
 486   case POWER_604:    puts ("powerpc604"); break;
 487 #endif
 488 #ifdef POWER_620
 489   case POWER_620:    puts ("powerpc620"); break;
 490 #endif
 491 #ifdef POWER_630
 492   case POWER_630:    puts ("powerpc630"); break;
 493 #endif
 494   /* Dunno what this is, leave it out for now.
 495   case POWER_A35:    puts ("powerpca35"); break;
 496   */
 497   /* This is waiting for a bit more info.
 498   case POWER_RS64II: puts ("powerpcrs64ii"); break;
 499   */
 500 #ifdef POWER_4
 501   case POWER_4:    puts ("power4"); break;
 502 #endif
 503 #ifdef POWER_5
 504   case POWER_5:    puts ("power5"); break;
 505 #endif
 506 #ifdef POWER_6
 507   case POWER_6:    puts ("power6"); break;
 508 #endif
 509 #ifdef POWER_7
 510   case POWER_7:    puts ("power7"); break;
 511 #endif
 512   default:
 513     if (_system_configuration.architecture == POWER_RS)
 514       puts ("power");
 515     else if (_system_configuration.width == 64)
 516       puts ("powerpc64");
 517   }
 518   return 0;
 519 }
 520 EOF
 521     if ($CC_FOR_BUILD $dummy.c -o $dummy) >/dev/null 2>&1; then
 522       x=`$dummy`
 523       if test -n "$x"; then
 524         exact_cpu=$x
 525       fi
 526     fi
 527   fi
 528
 529   if test -z "$exact_cpu"; then
 530     # On MacOS X (or any Mach-O presumably), NXGetLocalArchInfo cpusubtype
 531     # can tell us the exact cpu.
 532     cat >$dummy.c <<EOF
 533 #include <stdio.h>
 534 #include <mach-o/arch.h>
 535 int
 536 main (void)
 537 {
 538   const NXArchInfo *a = NXGetLocalArchInfo();
 539   if (a->cputype == CPU_TYPE_POWERPC)
 540     {
 541       switch (a->cpusubtype) {
 542       /* The following known to Darwin 1.3. */
 543       case CPU_SUBTYPE_POWERPC_601:   puts ("powerpc601");  break;
 544       case CPU_SUBTYPE_POWERPC_602:   puts ("powerpc602");  break;
 545       case CPU_SUBTYPE_POWERPC_603:   puts ("powerpc603");  break;
 546       case CPU_SUBTYPE_POWERPC_603e:  puts ("powerpc603e"); break;
 547       case CPU_SUBTYPE_POWERPC_603ev: puts ("powerpc603e"); break;
 548       case CPU_SUBTYPE_POWERPC_604:   puts ("powerpc604");  break;
 549       case CPU_SUBTYPE_POWERPC_604e:  puts ("powerpc604e"); break;
 550       case CPU_SUBTYPE_POWERPC_620:   puts ("powerpc620");  break;
 551       case CPU_SUBTYPE_POWERPC_750:   puts ("powerpc750");  break;
 552       case CPU_SUBTYPE_POWERPC_7400:  puts ("powerpc7400"); break;
 553       case CPU_SUBTYPE_POWERPC_7450:  puts ("powerpc7450"); break;
 554       /* Darwin 6.8.5 doesn't define the following */
 555       case 0x8001:                    puts ("powerpc7455"); break;
 556       case 0x8002:                    puts ("powerpc7457"); break;
 557       case 0x8003:                    puts ("powerpc7447"); break;
 558       case 100:                       puts ("powerpc970");  break;
 559       }
 560     }
 561   return 0;
 562 }
 563 EOF
 564     if ($CC_FOR_BUILD $dummy.c -o $dummy) >/dev/null 2>&1; then
 565       x=`$dummy`
 566       if test -n "$x"; then
 567         exact_cpu=$x
 568       fi
 569     fi
 570   fi
 571   ;;
 572
 573 sparc-*-* | sparc64-*-*)
 574   # If we can recognise an actual v7 then $exact_cpu is set to "sparc" so as
 575   # to short-circuit subsequent tests.
 576
 577   # Grep the linux kernel /proc/cpuinfo pseudo-file.
 578   # A typical line is "cpu\t\t: TI UltraSparc II  (BlackBird)"
 579   # See arch/sparc/kernel/cpu.c and arch/sparc64/kernel/cpu.c.
 580   #
 581   if test -f /proc/cpuinfo; then
 582     if grep 'cpu.*Cypress' /proc/cpuinfo >/dev/null; then
 583       exact_cpu="sparc"   # ie. v7
 584     elif grep 'cpu.*Power-UP' /proc/cpuinfo >/dev/null; then
 585       exact_cpu="sparc"   # ie. v7
 586     elif grep 'cpu.*HyperSparc' /proc/cpuinfo >/dev/null; then
 587       exact_cpu="sparcv8"
 588     elif grep 'cpu.*SuperSparc' /proc/cpuinfo >/dev/null; then
 589       exact_cpu="supersparc"
 590     elif grep 'cpu.*MicroSparc' /proc/cpuinfo >/dev/null; then
 591       exact_cpu="microsparc"
 592     elif grep 'cpu.*MB86904' /proc/cpuinfo >/dev/null; then
 593       # actually MicroSPARC-II
 594       exact_cpu=microsparc
 595     elif grep 'cpu.*UltraSparc T4' /proc/cpuinfo >/dev/null; then
 596       exact_cpu="ultrasparct4"
 597     elif grep 'cpu.*UltraSparc T3' /proc/cpuinfo >/dev/null; then
 598       exact_cpu="ultrasparct3"
 599     elif grep 'cpu.*UltraSparc T2' /proc/cpuinfo >/dev/null; then
 600       exact_cpu="ultrasparct2"
 601     elif grep 'cpu.*UltraSparc T1' /proc/cpuinfo >/dev/null; then
 602       exact_cpu="ultrasparct1"
 603     elif grep 'cpu.*UltraSparc III' /proc/cpuinfo >/dev/null; then
 604       exact_cpu="ultrasparc3"
 605     elif grep 'cpu.*UltraSparc IIi' /proc/cpuinfo >/dev/null; then
 606       exact_cpu="ultrasparc2i"
 607     elif grep 'cpu.*UltraSparc II' /proc/cpuinfo >/dev/null; then
 608       exact_cpu="ultrasparc2"
 609     elif grep 'cpu.*UltraSparc' /proc/cpuinfo >/dev/null; then
 610       exact_cpu="ultrasparc"
 611     fi
 612   fi
 613
 614   # Need to invoke this for setup of $dummy
 615   eval $set_cc_for_build
 616
 617   # Grep the output from sysinfo on SunOS.
 618   # sysinfo has been seen living in /bin or in /usr/kvm
 619   #     cpu0 is a "SuperSPARC Model 41 SPARCmodule" CPU
 620   #     cpu0 is a "75 MHz TI,TMS390Z55" CPU
 621   #
 622   if test -z "$exact_cpu"; then
 623     for i in sysinfo /usr/kvm/sysinfo; do
 624       if $SHELL -c $i 2>/dev/null >$dummy; then
 625         if grep 'cpu0 is a "SuperSPARC' $dummy >/dev/null; then
 626           exact_cpu=supersparc
 627           break
 628         elif grep 'cpu0 is a .*TMS390Z5.' $dummy >/dev/null; then
 629           # TMS390Z50 and TMS390Z55
 630           exact_cpu=supersparc
 631           break
 632         fi
 633       fi
 634     done
 635   fi
 636
 637   # Grep the output from prtconf on Solaris.
 638   # Use an explicit /usr/sbin, since that directory might not be in a normal
 639   # user's path.
 640   #
 641   #     SUNW,UltraSPARC (driver not attached)
 642   #     SUNW,UltraSPARC-II (driver not attached)
 643   #     SUNW,UltraSPARC-IIi (driver not attached)
 644   #     SUNW,UltraSPARC-III+ (driver not attached)
 645   #     Ross,RT625 (driver not attached)
 646   #     TI,TMS390Z50 (driver not attached)
 647   #
 648   # /usr/sbin/sysdef prints similar information, but includes all loadable
 649   # cpu modules, not just the real cpu.
 650   #
 651   # We first try a plain prtconf, since that is known to work on older systems.
 652   # But for newer T1 systems, that doesn't produce any useful output, we need
 653   # "prtconf -vp" there.
 654   #
 655   for prtconfopt in "" "-vp"; do
 656     if test -z "$exact_cpu"; then
 657       if $SHELL -c "/usr/sbin/prtconf $prtconfopt" 2>/dev/null >$dummy; then
 658         if grep 'SUNW,UltraSPARC-T3' $dummy >/dev/null; then
 659           exact_cpu=ultrasparct3
 660         elif grep 'SUNW,UltraSPARC-T2' $dummy >/dev/null; then
 661           exact_cpu=ultrasparct2
 662         elif grep 'SUNW,UltraSPARC-T1' $dummy >/dev/null; then
 663           exact_cpu=ultrasparct1
 664         elif grep 'SUNW,UltraSPARC-III' $dummy >/dev/null; then
 665           exact_cpu=ultrasparc3
 666         elif grep 'SUNW,UltraSPARC-IIi' $dummy >/dev/null; then
 667           exact_cpu=ultrasparc2i
 668         elif grep 'SUNW,UltraSPARC-II' $dummy >/dev/null; then
 669           exact_cpu=ultrasparc2
 670         elif grep 'SUNW,UltraSPARC' $dummy >/dev/null; then
 671           exact_cpu=ultrasparc
 672         elif grep 'Ross,RT62.' $dummy >/dev/null; then
 673           # RT620, RT625, RT626 hypersparcs (v8).
 674           exact_cpu=sparcv8
 675         elif grep 'TI,TMS390Z5.' $dummy >/dev/null; then
 676           # TMS390Z50 and TMS390Z55
 677           exact_cpu=supersparc
 678         elif grep 'TI,TMS390S10' $dummy >/dev/null; then
 679           exact_cpu=microsparc
 680         elif grep 'FMI,MB86904' $dummy >/dev/null; then
 681           # actually MicroSPARC-II
 682           exact_cpu=microsparc
 683         fi
 684       fi
 685     fi
 686   done
 687
 688   # Grep the output from sysctl hw.model on sparc or sparc64 *BSD.
 689   # Use an explicit /sbin, since that directory might not be in a normal
 690   # user's path.  Example outputs,
 691   #
 692   #     hw.model: Sun Microsystems UltraSparc-IIi
 693   #
 694   if test -z "$exact_cpu"; then
 695     if $SHELL -c "/sbin/sysctl hw.model" 2>/dev/null >$dummy; then
 696       if grep -i 'UltraSparc-T3' $dummy >/dev/null; then
 697         exact_cpu=ultrasparct3
 698       elif grep -i 'UltraSparc-T2' $dummy >/dev/null; then
 699         exact_cpu=ultrasparct2
 700       elif grep -i 'UltraSparc-T1' $dummy >/dev/null; then
 701         exact_cpu=ultrasparct1
 702       elif grep -i 'UltraSparc-III' $dummy >/dev/null; then
 703         exact_cpu=ultrasparc3
 704       elif grep -i 'UltraSparc-IIi' $dummy >/dev/null; then
 705         exact_cpu=ultrasparc2i
 706       elif grep -i 'UltraSparc-II' $dummy >/dev/null; then
 707         exact_cpu=ultrasparc2
 708       elif grep -i 'UltraSparc' $dummy >/dev/null; then
 709         exact_cpu=ultrasparc
 710       elif grep 'TMS390Z5.' $dummy >/dev/null; then
 711         # TMS390Z50 and TMS390Z55
 712         exact_cpu=supersparc
 713       elif grep 'TMS390S10' $dummy >/dev/null; then
 714         exact_cpu=microsparc
 715       elif grep 'MB86904' $dummy >/dev/null; then
 716         # actually MicroSPARC-II
 717         exact_cpu=microsparc
 718       elif grep 'MB86907' $dummy >/dev/null; then
 719         exact_cpu=turbosparc
 720       fi
 721     fi
 722   fi
 723
 724   # sun4m and sun4d are v8s of some sort, sun4u is a v9 of some sort
 725   #
 726   if test -z "$exact_cpu"; then
 727     case `uname -m` in
 728       sun4[md]) exact_cpu=sparcv8 ;;
 729       sun4u)    exact_cpu=sparcv9 ;;
 730     esac
 731   fi
 732   ;;
 733
 734
 735 # Recognise x86 processors using a tricky cpuid with 4 arguments, repeating
 736 # arguments; for x86-64 we effectively pass the 1st in rdx and the 2nd in rcx.
 737 # This allows the same asm to work for both standard and Windoze calling
 738 # conventions.
 739
 740 i?86-*-* | amd64-*-* | x86_64-*-*)
 741   eval $set_cc_for_build
 742
 743   cat <<EOF >$dummy.c
 744 #include <string.h>
 745 #include <stdio.h>
 746 #define CPUID(a,b) cpuid(b,a,a,b)
 747 #if __cplusplus
 748 extern "C"
 749 #endif
 750 unsigned int cpuid (int, char *, char *, int);
 751 int
 752 main ()
 753 {
 754   char vendor_string[13];
 755   char dummy_string[12];
 756   long fms;
 757   int family, model, stepping;
 758   const char *modelstr;
 759   int cpu_64bit = 0;
 760   int cpuid_64bit;
 761
 762   CPUID (vendor_string, 0);
 763   vendor_string[12] = 0;
 764
 765   fms = CPUID (dummy_string, 1);
 766
 767   family = ((fms >> 8) & 0xf) + ((fms >> 20) & 0xff);
 768   model = ((fms >> 4) & 0xf) + ((fms >> 12) & 0xf0);
 769   stepping = fms & 0xf;
 770
 771   modelstr = "$guess_cpu";
 772
 773   /**************************************************/
 774   /*** WARNING: keep this list in sync with fat.c ***/
 775   /**************************************************/
 776   if (strcmp (vendor_string, "GenuineIntel") == 0)
 777     {
 778       switch (family)
 779         {
 780         case 5:
 781           if (model <= 2)       modelstr = "pentium";
 782           else if (model >= 4)  modelstr = "pentiummmx";
 783           break;
 784         case 6:
 785           if (model <= 1)                        modelstr = "pentiumpro";
 786           else if (model <= 6)                   modelstr = "pentium2";
 787           else if (model <= 8)                   modelstr = "pentium3";
 788           else if (model <= 9)                   modelstr = "pentiumm";
 789           else if (model <= 0x0c)                modelstr = "pentium3";
 790           else if (model <= 0x0e)                modelstr = "pentiumm";
 791           else if (model <= 0x19) cpu_64bit = 1, modelstr = "core2";
 792           else if (model == 0x1a) cpu_64bit = 1, modelstr = "coreinhm"; /* NHM Gainestown */
 793           else if (model == 0x1c) cpu_64bit = 1, modelstr = "atom";     /* Silverthorne */
 794           else if (model == 0x1d) cpu_64bit = 1, modelstr = "core2";    /* PNR Dunnington */
 795           else if (model == 0x1e) cpu_64bit = 1, modelstr = "coreinhm"; /* NHM Lynnfield/Jasper */
 796           else if (model == 0x25) cpu_64bit = 1, modelstr = "coreiwsm"; /* WSM Clarkdale/Arrandale */
 797           else if (model == 0x26) cpu_64bit = 1, modelstr = "atom";     /* Lincroft */
 798           else if (model == 0x27) cpu_64bit = 1, modelstr = "atom";     /* Saltwell */
 799           else if (model == 0x2a) cpu_64bit = 1, modelstr = "coreisbr"; /* SB */
 800           else if (model == 0x2c) cpu_64bit = 1, modelstr = "coreiwsm"; /* WSM Gulftown */
 801           else if (model == 0x2d) cpu_64bit = 1, modelstr = "coreisbr"; /* SBC-EP */
 802           else if (model == 0x2e) cpu_64bit = 1, modelstr = "coreinhm"; /* NHM Beckton */
 803           else if (model == 0x2f) cpu_64bit = 1, modelstr = "coreiwsm"; /* WSM Eagleton */
 804           else if (model == 0x36) cpu_64bit = 1, modelstr = "atom";     /* Cedarview/Saltwell */
 805           else if (model == 0x37) cpu_64bit = 1, modelstr = "coreinhm"; /* Atom Silvermont */
 806           else if (model == 0x3a) cpu_64bit = 1, modelstr = "coreisbr"; /* IBR */
 807           else if (model == 0x3c) cpu_64bit = 1, modelstr = "coreihwl"; /* Haswell client */
 808           else if (model == 0x3d) cpu_64bit = 1, modelstr = "coreibwl"; /* Broadwell */
 809           else if (model == 0x3e) cpu_64bit = 1, modelstr = "coreisbr"; /* Ivytown */
 810           else if (model == 0x3f) cpu_64bit = 1, modelstr = "coreihwl"; /* Haswell server */
 811           else if (model == 0x45) cpu_64bit = 1, modelstr = "coreihwl"; /* Haswell ULT */
 812           else if (model == 0x46) cpu_64bit = 1, modelstr = "coreihwl"; /* Crystal Well */
 813           else if (model == 0x4d) cpu_64bit = 1, modelstr = "coreinhm"; /* Silvermont/Avoton */
 814           else if (model == 0x4f) cpu_64bit = 1, modelstr = "coreibwl"; /* Broadwell server */
 815           else if (model == 0x56) cpu_64bit = 1, modelstr = "coreibwl"; /* Broadwell microserver */
 816           else cpu_64bit = 1, modelstr = "corei"; /* default */
 817
 818           if (strcmp (modelstr, "coreihwl") == 0)
 819             {
 820               /* Some Haswells lack BMI2.  Let them appear as Sandybridges for
 821                  now.  */
 822               CPUID (dummy_string, 7);
 823               if ((dummy_string[0 + 8 / 8] & (1 << (8 % 8))) == 0)
 824                 modelstr = "coreisbr";
 825             }
 826
 827           break;
 828         case 15:
 829           cpu_64bit = 1, modelstr = "pentium4";
 830           break;
 831         }
 832     }
 833   else if (strcmp (vendor_string, "AuthenticAMD") == 0)
 834     {
 835       switch (family)
 836         {
 837         case 5:
 838           if (model <= 3)       modelstr = "k5";
 839           else if (model <= 7)  modelstr = "k6";
 840           else if (model == 8)  modelstr = "k62";
 841           else if (model == 9)  modelstr = "k63";
 842           else if (model == 10) modelstr = "geode";
 843           else if (model == 13) modelstr = "k63";
 844           break;
 845         case 6:
 846           modelstr = "athlon";
 847           break;
 848         case 15:                /* K8, K9 */
 849           cpu_64bit = 1, modelstr = "k8";
 850           break;
 851         case 16:                /* K10 */
 852           cpu_64bit = 1, modelstr = "k10";
 853           break;
 854         case 17:                /* Hybrid k8/k10, claim k8 */
 855           cpu_64bit = 1, modelstr = "k8";
 856           break;
 857         case 18:                /* Llano, uses K10 core */
 858           cpu_64bit = 1, modelstr = "k10";
 859           break;
 860         case 19:                /* AMD Internal, assume future K10 */
 861           cpu_64bit = 1, modelstr = "k10";
 862           break;
 863         case 20:                /* Bobcat */
 864           cpu_64bit = 1, modelstr = "bobcat";
 865           break;
 866         case 21:                /* Bulldozer */
 867           cpu_64bit = 1;
 868           if (model <= 1)
 869             modelstr = "bulldozer";
 870           else if (model < 0x20)        /* really 2, [0x10-0x20) */
 871             modelstr = "piledriver";
 872           else if (model < 0x40)        /* really [0x30-0x40) */
 873             modelstr = "steamroller";
 874           else                          /* really [0x60-0x70) */
 875             modelstr = "excavator";
 876           break;
 877         case 22:                /* Jaguar, an improved bobcat */
 878           cpu_64bit = 1, modelstr = "jaguar";
 879           break;
 880         }
 881     }
 882   else if (strcmp (vendor_string, "CyrixInstead") == 0)
 883     {
 884       /* Should recognize Cyrix' processors too.  */
 885     }
 886   else if (strcmp (vendor_string, "CentaurHauls") == 0)
 887     {
 888       switch (family)
 889         {
 890         case 6:
 891           if (model < 9)        modelstr = "viac3";
 892           else if (model < 15)  modelstr = "viac32";
 893           else                  cpu_64bit = 1, modelstr = "nano";
 894           break;
 895         }
 896     }
 897
 898   CPUID (dummy_string, 0x80000001);
 899   cpuid_64bit = (dummy_string[7] >> 5) & 1;
 900
 901   /* If our cpuid-based CPU identification thinks this is a 32-bit CPU but
 902      cpuid claims AMD64 capabilities, then revert to the generic "x86_64".
 903      This is of course wrong, but it can happen in some emulators, so this
 904      workaround allows for successful 64-bit builds.  */
 905   if (cpuid_64bit && ! cpu_64bit)
 906     modelstr = "x86_64";
 907
 908   printf ("%s", modelstr);
 909   return 0;
 910 }
 911 EOF
 912
 913 # The rcx/ecx zeroing here and in the variant below is needed for the BMI2
 914 # check.
 915
 916   cat <<EOF >${dummy}0.s
 917         .globl cpuid
 918         .globl _cpuid
 919 cpuid:
 920 _cpuid:
 921         push    %rbx
 922         mov     %rdx, %r8
 923         mov     %ecx, %eax
 924         xor     %ecx, %ecx
 925         .byte   0x0f
 926         .byte   0xa2
 927         mov     %ebx, (%r8)
 928         mov     %edx, 4(%r8)
 929         mov     %ecx, 8(%r8)
 930         pop     %rbx
 931         ret
 932 EOF
 933
 934   if ($CC_FOR_BUILD ${dummy}0.s $dummy.c -o $dummy) >/dev/null 2>&1; then
 935     # On 80386 and early 80486 cpuid is not available and will result in a
 936     # SIGILL message, hence 2>/dev/null.
 937     #
 938     # On i386-unknown-freebsd4.9, "/bin/sh -c ./dummy" seems to send an
 939     # "Illegal instruction (core dumped)" message to stdout, so we test $?
 940     # to check if the program run was successful.
 941     #
 942     x=`$SHELL -c $dummy 2>/dev/null`
 943     if test $? = 0 && test -n "$x"; then
 944       exact_cpu=$x
 945     fi
 946   fi
 947
 948   cat <<EOF >${dummy}0.s
 949         .globl cpuid
 950         .globl _cpuid
 951 cpuid:
 952 _cpuid:
 953         pushl %esi
 954         pushl %ebx
 955         movl 24(%esp),%eax
 956         xor     %ecx, %ecx
 957         .byte 0x0f
 958         .byte 0xa2
 959         movl 20(%esp),%esi
 960         movl %ebx,(%esi)
 961         movl %edx,4(%esi)
 962         movl %ecx,8(%esi)
 963         popl %ebx
 964         popl %esi
 965         ret
 966 EOF
 967
 968   if test -z "$exact_cpu"; then
 969   if ($CC_FOR_BUILD ${dummy}0.s $dummy.c -o $dummy) >/dev/null 2>&1; then
 970     # On 80386 and early 80486 cpuid is not available and will result in a
 971     # SIGILL message, hence 2>/dev/null.
 972     #
 973     # On i386-unknown-freebsd4.9, "/bin/sh -c ./dummy" seems to send an
 974     # "Illegal instruction (core dumped)" message to stdout, so we test $?
 975     # to check if the program run was successful.
 976     #
 977     x=`$SHELL -c $dummy 2>/dev/null`
 978     if test $? = 0 && test -n "$x"; then
 979       exact_cpu=$x
 980     fi
 981   fi
 982   fi
 983
 984   # We need to remove some .o files here since lame C compilers
 985   # generate these even when not asked.
 986   ;;
 987
 988 s390*-*-*)
 989   model=`grep "^processor 0: version =" /proc/cpuinfo | sed -e 's/.*machine = //'`
 990   case $model in
 991     2064 | 2066) zcpu="z900" ;;
 992     2084 | 2086) zcpu="z990" ;;
 993     2094 | 2096) zcpu="z9"   ;;
 994     2097 | 2098) zcpu="z10"  ;;
 995     2817 | 2818 | *) zcpu="z196" ;;
 996   esac
 997   case "$guess_full" in
 998     s390x-*-*) exact_cpu=${zcpu}    ;;
 999     s390-*-*)  exact_cpu=${zcpu}esa ;;
1000   esac
1001   ;;
1002
1003 esac
1004
1005
1006
1007 # -------------------------------------------------------------------------
1008 # Use an exact cpu, if possible
1009
1010 if test -n "$exact_cpu"; then
1011   echo "$exact_cpu$guess_rest"
1012 else
1013   echo "$guess_full"
1014 fi
1015 exit 0
1016
1017
1018
1019 # Local variables:
1020 # fill-column: 76
1021 # End: