configure
上传用户:qaz666999
上传日期:2022-08-06
资源大小:2570k
文件大小:938k
源码类别:

数学计算

开发平台:

Unix_Linux

  1. case $enable_nails in
  2. yes) GMP_NAIL_BITS=2 ;;
  3. no)  GMP_NAIL_BITS=0 ;;
  4. *)   GMP_NAIL_BITS=$enable_nails ;;
  5. esac
  6. # Check whether --enable-profiling was given.
  7. if test "${enable_profiling+set}" = set; then :
  8.   enableval=$enable_profiling; case $enableval in
  9. no|prof|gprof|instrument) ;;
  10. *) as_fn_error "bad value $enableval for --enable-profiling, need no/prof/gprof/instrument" "$LINENO" 5 ;;
  11. esac
  12. else
  13.   enable_profiling=no
  14. fi
  15. case $enable_profiling in
  16.   prof)
  17. $as_echo "#define WANT_PROFILING_PROF 1" >>confdefs.h
  18.     ;;
  19.   gprof)
  20. $as_echo "#define WANT_PROFILING_GPROF 1" >>confdefs.h
  21.     ;;
  22.   instrument)
  23. $as_echo "#define WANT_PROFILING_INSTRUMENT 1" >>confdefs.h
  24.     ;;
  25. esac
  26. echo "define(<WANT_PROFILING>,<`$enable_profiling'>)" >> $gmp_tmpconfigm4
  27. # -fomit-frame-pointer is incompatible with -pg on some chips
  28. if test "$enable_profiling" = gprof; then
  29.   fomit_frame_pointer=
  30. else
  31.   fomit_frame_pointer="-fomit-frame-pointer"
  32. fi
  33. # Check whether --with-readline was given.
  34. if test "${with_readline+set}" = set; then :
  35.   withval=$with_readline; case $withval in
  36. yes|no|detect) ;;
  37. *) as_fn_error "bad value $withval for --with-readline, need yes/no/detect" "$LINENO" 5 ;;
  38. esac
  39. else
  40.   with_readline=detect
  41. fi
  42. # Check whether --enable-fat was given.
  43. if test "${enable_fat+set}" = set; then :
  44.   enableval=$enable_fat; case $enableval in
  45. yes|no) ;;
  46. *) as_fn_error "bad value $enableval for --enable-fat, need yes or no" "$LINENO" 5 ;;
  47. esac
  48. else
  49.   enable_fat=no
  50. fi
  51. # Check whether --enable-minithres was given.
  52. if test "${enable_minithres+set}" = set; then :
  53.   enableval=$enable_minithres; case $enableval in
  54. yes|no) ;;
  55. *) as_fn_error "bad value $enableval for --enable-minithres, need yes or no" "$LINENO" 5 ;;
  56. esac
  57. else
  58.   enable_minithres=no
  59. fi
  60. tmp_host=`echo $host_cpu | sed 's/./_/'`
  61. cat >>confdefs.h <<_ACEOF
  62. #define HAVE_HOST_CPU_$tmp_host 1
  63. _ACEOF
  64. echo "define_not_for_expansion(`HAVE_HOST_CPU_$tmp_host')" >> $gmp_tmpconfigm4p
  65. # Table of compilers, options, and mpn paths.  This code has various related
  66. # purposes
  67. #
  68. #   - better default CC/CFLAGS selections than autoconf otherwise gives
  69. #   - default CC/CFLAGS selections for extra CPU types specific to GMP
  70. #   - a few tests for known bad compilers
  71. #   - choice of ABIs on suitable systems
  72. #   - selection of corresponding mpn search path
  73. #
  74. # After GMP specific searches and tests, the standard autoconf AC_PROG_CC is
  75. # called.  User selections of CC etc are respected.
  76. #
  77. # Care is taken not to use macros like AC_TRY_COMPILE during the GMP
  78. # pre-testing, since they of course depend on AC_PROG_CC, and also some of
  79. # them cache their results, which is not wanted.
  80. #
  81. # The ABI selection mechanism is unique to GMP.  All that reaches autoconf
  82. # is a different selection of CC/CFLAGS according to the best ABI the system
  83. # supports, and/or what the user selects.  Naturally the mpn assembler code
  84. # selected is very dependent on the ABI.
  85. #
  86. # The closest the standard tools come to a notion of ABI is something like
  87. # "sparc64" which encodes a CPU and an ABI together.  This doesn't seem to
  88. # scale well for GMP, where exact CPU types like "ultrasparc2" are wanted,
  89. # separate from the ABI used on them.
  90. #
  91. #
  92. # The variables set here are
  93. #
  94. #   cclist              the compiler choices
  95. #   xx_cflags           flags for compiler xx
  96. #   xx_cflags_maybe     flags for compiler xx, if they work
  97. #   xx_cppflags         cpp flags for compiler xx
  98. #   xx_cflags_optlist   list of sets of optional flags
  99. #   xx_cflags_yyy       set yyy of optional flags for compiler xx
  100. #   xx_ldflags          -Wc,-foo flags for libtool linking with compiler xx
  101. #   ar_flags            extra flags for $AR
  102. #   nm_flags            extra flags for $NM
  103. #   limb                limb size, can be "longlong"
  104. #   path                mpn search path
  105. #   extra_functions     extra mpn functions
  106. #   fat_path            fat binary mpn search path [if fat binary desired]
  107. #   fat_functions       fat functions
  108. #   fat_thresholds      fat thresholds
  109. #
  110. # Suppose xx_cflags_optlist="arch", then flags from $xx_cflags_arch are
  111. # tried, and the first flag that works will be used.  An optlist like "arch
  112. # cpu optimize" can be used to get multiple independent sets of flags tried.
  113. # The first that works from each will be used.  If no flag in a set works
  114. # then nothing from that set is added.
  115. #
  116. # For multiple ABIs, the scheme extends as follows.
  117. #
  118. #   abilist               set of ABI choices
  119. #   cclist_aa             compiler choices in ABI aa
  120. #   xx_aa_cflags          flags for xx in ABI aa
  121. #   xx_aa_cflags_maybe    flags for xx in ABI aa, if they work
  122. #   xx_aa_cppflags        cpp flags for xx in ABI aa
  123. #   xx_aa_cflags_optlist  list of sets of optional flags in ABI aa
  124. #   xx_aa_cflags_yyy      set yyy of optional flags for compiler xx in ABI aa
  125. #   xx_aa_ldflags         -Wc,-foo flags for libtool linking
  126. #   ar_aa_flags           extra flags for $AR in ABI aa
  127. #   nm_aa_flags           extra flags for $NM in ABI aa
  128. #   limb_aa               limb size in ABI aa, can be "longlong"
  129. #   path_aa               mpn search path in ABI aa
  130. #   extra_functions_aa    extra mpn functions in ABI aa
  131. #
  132. # As a convenience, the unadorned xx_cflags (etc) are used for the last ABI
  133. # in ablist, if an xx_aa_cflags for that ABI isn't given.  For example if
  134. # abilist="64 32" then $cc_64_cflags will be used for the 64-bit ABI, but
  135. # for the 32-bit either $cc_32_cflags or $cc_cflags is used, whichever is
  136. # defined.  This makes it easy to add some 64-bit compilers and flags to an
  137. # unadorned 32-bit set.
  138. #
  139. # limb=longlong (or limb_aa=longlong) applies to all compilers within that
  140. # ABI.  It won't work to have some needing long long and some not, since a
  141. # single instantiated gmp.h will be used by both.
  142. #
  143. # SPEED_CYCLECOUNTER, cyclecounter_size and CALLING_CONVENTIONS_OBJS are
  144. # also set here, with an ABI suffix.
  145. #
  146. #
  147. #
  148. # A table-driven approach like this to mapping cpu type to good compiler
  149. # options is a bit of a maintenance burden, but there's not much uniformity
  150. # between options specifications on different compilers.  Some sort of
  151. # separately updatable tool might be cute.
  152. #
  153. # The use of lots of variables like this, direct and indirect, tends to
  154. # obscure when and how various things are done, but unfortunately it's
  155. # pretty much the only way.  If shell subroutines were portable then actual
  156. # code like "if this .. do that" could be written, but attempting the same
  157. # with full copies of GMP_PROG_CC_WORKS etc expanded at every point would
  158. # hugely bloat the output.
  159. # abilist needs to be non-empty, "standard" is just a generic name here
  160. abilist="standard"
  161. # FIXME: We'd like to prefer an ANSI compiler, perhaps by preferring
  162. # c89 over cc here.  But note that on HP-UX c89 provides a castrated
  163. # environment, and would want to be excluded somehow.  Maybe
  164. # AC_PROG_CC_STDC already does enough to stick cc into ANSI mode and
  165. # we don't need to worry.
  166. #
  167. cclist="gcc cc"
  168. gcc_cflags="-O2 -pedantic"
  169. gcc_64_cflags="-O2 -pedantic"
  170. cc_cflags="-O"
  171. cc_64_cflags="-O"
  172. SPEED_CYCLECOUNTER_OBJ=
  173. cyclecounter_size=2
  174. HAVE_HOST_CPU_FAMILY_power=0
  175. HAVE_HOST_CPU_FAMILY_powerpc=0
  176. case $host in
  177.   a29k*-*-*)
  178.     path="a29k"
  179.     ;;
  180.   alpha*-*-*)
  181.     $as_echo "#define HAVE_HOST_CPU_FAMILY_alpha 1" >>confdefs.h
  182.     case $host_cpu in
  183.       alphaev5* | alphapca5*)
  184.        path="alpha/ev5 alpha" ;;
  185.       alphaev67 | alphaev68 | alphaev7*)
  186.         path="alpha/ev67 alpha/ev6 alpha" ;;
  187.       alphaev6)
  188. path="alpha/ev6 alpha" ;;
  189.       *)
  190.         path="alpha" ;;
  191.     esac
  192.     extra_functions="cntlz"
  193.     gcc_cflags_optlist="asm cpu oldas" # need asm ahead of cpu, see below
  194.     gcc_cflags_oldas="-Wa,-oldas"     # see GMP_GCC_WA_OLDAS.
  195.     # gcc 2.7.2.3 doesn't know any -mcpu= for alpha, apparently.
  196.     # gcc 2.95 knows -mcpu= ev4, ev5, ev56, pca56, ev6.
  197.     # gcc 3.0 adds nothing.
  198.     # gcc 3.1 adds ev45, ev67 (but ev45 is the same as ev4).
  199.     # gcc 3.2 adds nothing.
  200.     #
  201.     # gcc version "2.9-gnupro-99r1" under "-O2 -mcpu=ev6" strikes internal
  202.     # compiler errors too easily and is rejected by GMP_PROG_CC_WORKS.  Each
  203.     # -mcpu=ev6 below has a fallback to -mcpu=ev56 for this reason.
  204.     #
  205.     case $host_cpu in
  206.       alpha)        gcc_cflags_cpu="-mcpu=ev4" ;;
  207.       alphaev5)     gcc_cflags_cpu="-mcpu=ev5" ;;
  208.       alphaev56)    gcc_cflags_cpu="-mcpu=ev56" ;;
  209.       alphapca56 | alphapca57)
  210.                     gcc_cflags_cpu="-mcpu=pca56" ;;
  211.       alphaev6)     gcc_cflags_cpu="-mcpu=ev6 -mcpu=ev56" ;;
  212.       alphaev67 | alphaev68 | alphaev7*)
  213.                     gcc_cflags_cpu="-mcpu=ev67 -mcpu=ev6 -mcpu=ev56" ;;
  214.     esac
  215.     # gcc version "2.9-gnupro-99r1" on alphaev68-dec-osf5.1 has been seen
  216.     # accepting -mcpu=ev6, but not putting the assembler in the right mode
  217.     # for what it produces.  We need to do this for it, and need to do it
  218.     # before testing the -mcpu options.
  219.     #
  220.     # On old versions of gcc, which don't know -mcpu=, we believe an
  221.     # explicit -Wa,-mev5 etc will be necessary to put the assembler in
  222.     # the right mode for our .asm files and longlong.h asm blocks.
  223.     #
  224.     # On newer versions of gcc, when -mcpu= is known, we must give a -Wa
  225.     # which is at least as high as the code gcc will generate.  gcc
  226.     # establishes what it needs with a ".arch" directive, our command line
  227.     # option seems to override that.
  228.     #
  229.     # gas prior to 2.14 doesn't accept -mev67, but -mev6 seems enough for
  230.     # ctlz and cttz (in 2.10.0 at least).
  231.     #
  232.     # OSF `as' accepts ev68 but stupidly treats it as ev4.  -arch only seems
  233.     # to affect insns like ldbu which are expanded as macros when necessary.
  234.     # Insns like ctlz which were never available as macros are always
  235.     # accepted and always generate their plain code.
  236.     #
  237.     case $host_cpu in
  238.       alpha)        gcc_cflags_asm="-Wa,-arch,ev4 -Wa,-mev4" ;;
  239.       alphaev5)     gcc_cflags_asm="-Wa,-arch,ev5 -Wa,-mev5" ;;
  240.       alphaev56)    gcc_cflags_asm="-Wa,-arch,ev56 -Wa,-mev56" ;;
  241.       alphapca56 | alphapca57)
  242.                     gcc_cflags_asm="-Wa,-arch,pca56 -Wa,-mpca56" ;;
  243.       alphaev6)     gcc_cflags_asm="-Wa,-arch,ev6 -Wa,-mev6" ;;
  244.       alphaev67 | alphaev68 | alphaev7*)
  245.                     gcc_cflags_asm="-Wa,-arch,ev67 -Wa,-mev67 -Wa,-arch,ev6 -Wa,-mev6" ;;
  246.     esac
  247.     # It might be better to ask "cc" whether it's Cray C or DEC C,
  248.     # instead of relying on the OS part of $host.  But it's hard to
  249.     # imagine either of those compilers anywhere except their native
  250.     # systems.
  251.     #
  252. echo "include_mpn(`alpha/alpha-defs.m4')" >> $gmp_tmpconfigm4i
  253.     case $host in
  254.       *-cray-unicos*)
  255.         cc_cflags="-O" # no -g, it silently disables all optimizations
  256. echo "include_mpn(`alpha/unicos.m4')" >> $gmp_tmpconfigm4i
  257.         # Don't perform any assembly syntax tests on this beast.
  258.         gmp_asm_syntax_testing=no
  259.         ;;
  260.       *-*-osf*)
  261. echo "include_mpn(`alpha/default.m4')" >> $gmp_tmpconfigm4i
  262.         cc_cflags=""
  263.         cc_cflags_optlist="opt cpu"
  264.         # not sure if -fast works on old versions, so make it optional
  265. cc_cflags_opt="-fast -O2"
  266. # DEC C V5.9-005 knows ev4, ev5, ev56, pca56, ev6.
  267. # Compaq C V6.3-029 adds ev67.
  268. #
  269. case $host_cpu in
  270.   alpha)       cc_cflags_cpu="-arch~ev4~-tune~ev4" ;;
  271.   alphaev5)    cc_cflags_cpu="-arch~ev5~-tune~ev5" ;;
  272.   alphaev56)   cc_cflags_cpu="-arch~ev56~-tune~ev56" ;;
  273.   alphapca56 | alphapca57)
  274.             cc_cflags_cpu="-arch~pca56~-tune~pca56" ;;
  275.   alphaev6)    cc_cflags_cpu="-arch~ev6~-tune~ev6" ;;
  276.   alphaev67 | alphaev68 | alphaev7*)
  277.             cc_cflags_cpu="-arch~ev67~-tune~ev67 -arch~ev6~-tune~ev6" ;;
  278. esac
  279.         ;;
  280.       *)
  281. echo "include_mpn(`alpha/default.m4')" >> $gmp_tmpconfigm4i
  282.         ;;
  283.     esac
  284.     case $host in
  285.       *-*-unicos*)
  286.         # tune/alpha.asm assumes int==4bytes but unicos uses int==8bytes
  287.         ;;
  288.       *)
  289.         SPEED_CYCLECOUNTER_OBJ=alpha.lo
  290.         cyclecounter_size=1 ;;
  291.     esac
  292.     ;;
  293.   # Cray vector machines.
  294.   # This must come after alpha* so that we can recognize present and future
  295.   # vector processors with a wildcard.
  296.   *-cray-unicos*)
  297.     gmp_asm_syntax_testing=no
  298.     cclist="cc"
  299.     # We used to have -hscalar0 here as a workaround for miscompilation of
  300.     # mpz/import.c, but let's hope Cray fixes their bugs instead, since
  301.     # -hscalar0 causes disastrously poor code to be generated.
  302.     cc_cflags="-O3 -hnofastmd -htask0 -Wa,-B"
  303.     path="cray"
  304.     ;;
  305.   arm*-*-*)
  306.     path="arm"
  307.     gcc_cflags="$gcc_cflags $fomit_frame_pointer"
  308.     gcc_testlist="gcc-arm-umodsi"
  309. echo "include_mpn(`arm/arm-defs.m4')" >> $gmp_tmpconfigm4i
  310.     ;;
  311.   clipper*-*-*)
  312.     path="clipper"
  313.     ;;
  314.   # Fujitsu
  315.   f30[01]-fujitsu-sysv*)
  316.     cclist="gcc vcc"
  317.     # FIXME: flags for vcc?
  318.     vcc_cflags="-g"
  319.     path="fujitsu"
  320.     ;;
  321.   hppa*-*-*)
  322.     # HP cc (the one sold separately) is K&R by default, but AM_C_PROTOTYPES
  323.     # will add "-Ae", or "-Aa -D_HPUX_SOURCE", to put it into ansi mode, if
  324.     # possible.
  325.     #
  326.     # gcc for hppa 2.0 can be built either for 2.0n (32-bit) or 2.0w
  327.     # (64-bit), but not both, so there's no option to choose the desired
  328.     # mode, we must instead detect which of the two it is.  This is done by
  329.     # checking sizeof(long), either 4 or 8 bytes respectively.  Do this in
  330.     # ABI=1.0 too, in case someone tries to build that with a 2.0w gcc.
  331.     #
  332.     gcc_cflags_optlist="arch"
  333.     gcc_testlist="sizeof-long-4"
  334.     SPEED_CYCLECOUNTER_OBJ=hppa.lo
  335.     cyclecounter_size=1
  336.     # FIXME: For hppa2.0*, path should be "pa32/hppa2_0 pa32/hppa1_1 pa32".
  337.     # (Can't remember why this isn't done already, have to check what .asm
  338.     # files are available in each and how they run on a typical 2.0 cpu.)
  339.     #
  340.     case $host_cpu in
  341.       hppa1.0*)    path="pa32" ;;
  342.       hppa7000*)   path="pa32/hppa1_1 pa32" ;;
  343.       hppa2.0* | hppa64)
  344.                    path="pa32/hppa2_0 pa32/hppa1_1/pa7100 pa32/hppa1_1 pa32" ;;
  345.       *)           # default to 7100
  346.                    path="pa32/hppa1_1/pa7100 pa32/hppa1_1 pa32" ;;
  347.     esac
  348.     # gcc 2.7.2.3 knows -mpa-risc-1-0 and -mpa-risc-1-1
  349.     # gcc 2.95 adds -mpa-risc-2-0, plus synonyms -march=1.0, 1.1 and 2.0
  350.     #
  351.     # We don't use -mpa-risc-2-0 in ABI=1.0 because 64-bit registers may not
  352.     # be saved by the kernel on an old system.  Actually gcc (as of 3.2)
  353.     # only adds a few float instructions with -mpa-risc-2-0, so it would
  354.     # probably be safe, but let's not take the chance.  In any case, a
  355.     # configuration like --host=hppa2.0 ABI=1.0 is far from optimal.
  356.     #
  357.     case $host_cpu in
  358.       hppa1.0*)           gcc_cflags_arch="-mpa-risc-1-0" ;;
  359.       *)                  # default to 7100
  360.                           gcc_cflags_arch="-mpa-risc-1-1" ;;
  361.     esac
  362.     case $host_cpu in
  363.       hppa1.0*)    cc_cflags="+O2" ;;
  364.       *)           # default to 7100
  365.                    cc_cflags="+DA1.1 +O2" ;;
  366.     esac
  367.     case $host in
  368.       hppa2.0*-*-* | hppa64-*-*)
  369. cclist_20n="gcc cc"
  370.         abilist="2.0n 1.0"
  371.         path_20n="pa64"
  372. limb_20n=longlong
  373.         any_20n_testlist="sizeof-long-4"
  374.         SPEED_CYCLECOUNTER_OBJ_20n=hppa2.lo
  375.         cyclecounter_size_20n=2
  376.         # -mpa-risc-2-0 is only an optional flag, in case an old gcc is
  377.         # used.  Assembler support for 2.0 is essential though, for our asm
  378.         # files.
  379. gcc_20n_cflags="-O2"
  380. gcc_20n_cflags_optlist="arch"
  381.         gcc_20n_cflags_arch="-mpa-risc-2-0 -mpa-risc-1-1"
  382.         gcc_20n_testlist="sizeof-long-4 hppa-level-2.0"
  383.         cc_20n_cflags="+DA2.0 +e +O2 -Wl,+vnocompatwarnings"
  384.         cc_20n_testlist="hpc-hppa-2-0"
  385. # ABI=2.0w is available for hppa2.0w and hppa2.0, but not for
  386. # hppa2.0n, on the assumption that that the latter indicates a
  387. # desire for ABI=2.0n.
  388. case $host in
  389.         hppa2.0n-*-*) ;;
  390.         *)
  391.           # HPUX 10 and earlier cannot run 2.0w.  Not sure about other
  392.           # systems (GNU/Linux for instance), but lets assume they're ok.
  393.           case $host in
  394.             *-*-hpux[1-9] | *-*-hpux[1-9].* | *-*-hpux10 | *-*-hpux10.*) ;;
  395.             *)    abilist="2.0w $abilist" ;;
  396.           esac
  397.           cclist_20w="gcc cc"
  398.   gcc_20w_cflags="-O2 -mpa-risc-2-0"
  399.           cc_20w_cflags="+DD64 +O2"
  400.           cc_20w_testlist="hpc-hppa-2-0"
  401.           path_20w="pa64"
  402.   any_20w_testlist="sizeof-long-8"
  403.           SPEED_CYCLECOUNTER_OBJ_20w=hppa2w.lo
  404.           cyclecounter_size_20w=2
  405.   ;;
  406.         esac
  407.         ;;
  408.     esac
  409.     ;;
  410.   i960*-*-*)
  411.     path="i960"
  412.     ;;
  413.   ia64*-*-* | itanium-*-* | itanium2-*-*)
  414.     abilist="64"
  415. echo "include_mpn(`ia64/ia64-defs.m4')" >> $gmp_tmpconfigm4i
  416.     SPEED_CYCLECOUNTER_OBJ=ia64.lo
  417.     case $host_cpu in
  418.       itanium)   path="ia64/itanium  ia64" ;;
  419.       itanium2)  path="ia64/itanium2 ia64" ;;
  420.       *)         path="ia64" ;;
  421.     esac
  422.     gcc_64_cflags_optlist="tune"
  423.     gcc_32_cflags_optlist=$gcc_64_cflags_optlist
  424.     # gcc pre-release 3.4 adds -mtune itanium and itanium2
  425.     case $host_cpu in
  426.       itanium)   gcc_cflags_tune="-mtune=itanium" ;;
  427.       itanium2)  gcc_cflags_tune="-mtune=itanium2" ;;
  428.     esac
  429.     case $host in
  430.       *-*-linux*)
  431. cclist="gcc icc"
  432. icc_cflags="-no-gcc"
  433. icc_cflags_optlist="opt"
  434. # Don't use -O3, it is for "large data sets" and also miscompiles GMP.
  435. # But icc miscompiles GMP at any optimization level, at higher levels
  436. # it miscompiles more files...
  437. icc_cflags_opt="-O2 -O1"
  438. ;;
  439.       *-*-hpux*)
  440.         # HP cc sometimes gets internal errors if the optimization level is
  441.         # too high.  GMP_PROG_CC_WORKS detects this, the "_opt" fallbacks
  442.         # let us use whatever seems to work.
  443.         #
  444.         abilist="32 64"
  445.         cclist_32="gcc cc"
  446.         path_32="ia64"
  447.         cc_32_cflags=""
  448.         cc_32_cflags_optlist="opt"
  449.         cc_32_cflags_opt="+O3 +O2 +O1"
  450.         gcc_32_cflags="-milp32 -O2"
  451.         limb_32=longlong
  452.         SPEED_CYCLECOUNTER_OBJ_32=ia64.lo
  453.         cyclecounter_size_32=2
  454.         # Must have +DD64 in CPPFLAGS to get the right __LP64__ for headers,
  455.         # but also need it in CFLAGS for linking programs, since automake
  456.         # only uses CFLAGS when linking, not CPPFLAGS.
  457.         # FIXME: Maybe should use cc_64_ldflags for this, but that would
  458.         # need GMP_LDFLAGS used consistently by all the programs.
  459.         #
  460.         cc_64_cflags="+DD64"
  461.         cc_64_cppflags="+DD64"
  462.         cc_64_cflags_optlist="opt"
  463.         cc_64_cflags_opt="+O3 +O2 +O1"
  464.         gcc_64_cflags="$gcc_64_cflags -mlp64"
  465.         ;;
  466.     esac
  467.     ;;
  468.   # Motorola 68k
  469.   #
  470.   m68k-*-* | m68[0-9][0-9][0-9]-*-*)
  471.     $as_echo "#define HAVE_HOST_CPU_FAMILY_m68k 1" >>confdefs.h
  472. echo "include_mpn(`m68k/m68k-defs.m4')" >> $gmp_tmpconfigm4i
  473.     gcc_cflags="$gcc_cflags $fomit_frame_pointer"
  474.     gcc_cflags_optlist="arch"
  475.     # gcc 2.7.2 knows -m68000, -m68020, -m68030, -m68040.
  476.     # gcc 2.95 adds -mcpu32, -m68060.
  477.     # FIXME: Maybe "-m68020 -mnobitfield" would suit cpu32 on 2.7.2.
  478.     #
  479.     case $host_cpu in
  480.     m68020)  gcc_cflags_arch="-m68020" ;;
  481.     m68030)  gcc_cflags_arch="-m68030" ;;
  482.     m68040)  gcc_cflags_arch="-m68040" ;;
  483.     m68060)  gcc_cflags_arch="-m68060 -m68000" ;;
  484.     m68360)  gcc_cflags_arch="-mcpu32 -m68000" ;;
  485.     *)       gcc_cflags_arch="-m68000" ;;
  486.     esac
  487.     # FIXME: m68k/mc68020 looks like it's ok for cpu32, but this wants to be
  488.     # tested.  Will need to introduce an m68k/cpu32 if m68k/mc68020 ever uses
  489.     # the bitfield instructions.
  490.     case $host_cpu in
  491.     m680[234]0 | m68360)  path="m68k/mc68020 m68k" ;;
  492.     *)                      path="m68k" ;;
  493.     esac
  494.     ;;
  495.   # Motorola 88k
  496.   m88k*-*-*)
  497.     path="m88k"
  498.     ;;
  499.   m88110*-*-*)
  500.     gcc_cflags="$gcc_cflags -m88110"
  501.     path="m88k/mc88110 m88k"
  502.     ;;
  503.   # National Semiconductor 32k
  504.   ns32k*-*-*)
  505.     path="ns32k"
  506.     ;;
  507.   # IRIX 5 and earlier can only run 32-bit o32.
  508.   #
  509.   # IRIX 6 and up always has a 64-bit mips CPU can run n32 or 64.  n32 is
  510.   # preferred over 64, but only because that's been the default in past
  511.   # versions of GMP.  The two are equally efficient.
  512.   #
  513.   # Linux kernel 2.2.13 arch/mips/kernel/irixelf.c has a comment about not
  514.   # supporting n32 or 64.
  515.   #
  516.   # For reference, libtool (eg. 1.5.6) recognises the n32 ABI and knows the
  517.   # right options to use when linking (both cc and gcc), so no need for
  518.   # anything special from us.
  519.   #
  520.   mips*-*-*)
  521.     abilist="o32"
  522.     gcc_cflags_optlist="abi"
  523.     gcc_cflags_abi="-mabi=32"
  524.     gcc_testlist="gcc-mips-o32"
  525.     path="mips32"
  526.     cc_cflags="-O2 -o32"   # no -g, it disables all optimizations
  527.     # this suits both mips32 and mips64
  528. echo "include_mpn(`mips32/mips-defs.m4')" >> $gmp_tmpconfigm4i
  529.     case $host in
  530.       mips64*-*-* | mips*-*-irix[6789]*)
  531.         abilist="n32 64 o32"
  532.         cclist_n32="gcc cc"
  533.         gcc_n32_cflags="-O2 -mabi=n32"
  534.         cc_n32_cflags="-O2 -n32" # no -g, it disables all optimizations
  535.         limb_n32=longlong
  536.         path_n32="mips64"
  537.         cclist_64="gcc cc"
  538.         gcc_64_cflags="$gcc_64_cflags -mabi=64"
  539.         gcc_64_ldflags="-Wc,-mabi=64"
  540.         cc_64_cflags="-O2 -64" # no -g, it disables all optimizations
  541.         cc_64_ldflags="-Wc,-64"
  542.         path_64="mips64"
  543.         ;;
  544.     esac
  545.     ;;
  546.   # Darwin (powerpc-apple-darwin1.3) has it's hacked gcc installed as cc.
  547.   # Our usual "gcc in disguise" detection means gcc_cflags etc here gets
  548.   # used.
  549.   #
  550.   # The darwin pre-compiling preprocessor is disabled with -no-cpp-precomp
  551.   # since it doesn't like "__attribute__ ((mode (SI)))" etc in gmp-impl.h,
  552.   # and so always ends up running the plain preprocessor anyway.  This could
  553.   # be done in CPPFLAGS rather than CFLAGS, but there's not many places
  554.   # preprocessing is done separately, and this is only a speedup, the normal
  555.   # preprocessor gets run if there's any problems.
  556.   #
  557.   # We used to use -Wa,-mppc with gcc, but can't remember exactly why.
  558.   # Presumably it was for old versions of gcc where -mpowerpc doesn't put
  559.   # the assembler in the right mode.  In any case -Wa,-mppc is not good, for
  560.   # instance -mcpu=604 makes recent gcc use -m604 to get access to the
  561.   # "fsel" instruction, but a -Wa,-mppc overrides that, making code that
  562.   # comes out with fsel fail.
  563.   #
  564.   # (Note also that the darwin assembler doesn't accept "-mppc", so any
  565.   # -Wa,-mppc was used only if it worked.  The right flag on darwin would be
  566.   # "-arch ppc" or some such, but that's already the default.)
  567.   #
  568.   powerpc*-*-* | power[3-9]-*-*)
  569.     $as_echo "#define HAVE_HOST_CPU_FAMILY_powerpc 1" >>confdefs.h
  570.     HAVE_HOST_CPU_FAMILY_powerpc=1
  571.     abilist="32"
  572.     cclist="gcc cc"
  573.     cc_cflags="-O2"
  574.     gcc_cflags="$gcc_cflags -mpowerpc"
  575.     gcc_cflags_optlist="precomp subtype asm cpu"
  576.     gcc_cflags_precomp="-no-cpp-precomp"
  577.     gcc_cflags_subtype="-force_cpusubtype_ALL" # for vmx on darwin
  578.     gcc_cflags_asm=""
  579.     gcc_cflags_cpu=""
  580.     vmx_path=""
  581.     # grab this object, though it's not a true cycle counter routine
  582.     SPEED_CYCLECOUNTER_OBJ=powerpc.lo
  583.     cyclecounter_size=0
  584.     case $host_cpu in
  585.       powerpc740 | powerpc750)
  586.         path="powerpc32/750 powerpc32" ;;
  587.       powerpc7400 | powerpc7410)
  588.         path="powerpc32/vmx powerpc32/750 powerpc32" ;;
  589.       powerpc74[45]?)
  590.         path="powerpc32/vmx powerpc32" ;;
  591.       *)
  592.         path="powerpc32" ;;
  593.     esac
  594.     # gcc 2.7.2 knows -mcpu=403, 601, 603, 604.
  595.     # gcc 2.95 adds 401, 505, 602, 603e, ec603e, 604e, 620, 740, 750,
  596.     #   801, 821, 823, 860.
  597.     # gcc 3.0 adds 630, rs64a.
  598.     # gcc 3.1 adds 405, 7400, 7450.
  599.     # gcc 3.2 adds nothing.
  600.     # gcc 3.3 adds power3, power4, 8540.  power3 seems to be a synonym for 630.
  601.     # gcc pre-release 3.4 adds 405fp, 440, 440fp, 970.
  602.     #
  603.     # FIXME: The way 603e falls back to 603 for gcc 2.7.2 should be
  604.     # done for all the others too.  But what would be the correct
  605.     # arrangements?
  606.     #
  607.     case $host_cpu in
  608.       powerpc401)   gcc_cflags_cpu="-mcpu=401" ;;
  609.       powerpc403)   gcc_cflags_cpu="-mcpu=403" ;;
  610.       powerpc405)   gcc_cflags_cpu="-mcpu=405" ;;
  611.       powerpc505)   gcc_cflags_cpu="-mcpu=505" ;;
  612.       powerpc601)   gcc_cflags_cpu="-mcpu=601" ;;
  613.       powerpc602)   gcc_cflags_cpu="-mcpu=602" ;;
  614.       powerpc603)   gcc_cflags_cpu="-mcpu=603" ;;
  615.       powerpc603e)  gcc_cflags_cpu="-mcpu=603e -mcpu=603" ;;
  616.       powerpc604)   gcc_cflags_cpu="-mcpu=604" ;;
  617.       powerpc604e)  gcc_cflags_cpu="-mcpu=604e -mcpu=604" ;;
  618.       powerpc620)   gcc_cflags_cpu="-mcpu=620" ;;
  619.       powerpc630)   gcc_cflags_cpu="-mcpu=630"
  620.     cpu_path="p3" ;;
  621.       powerpc740)   gcc_cflags_cpu="-mcpu=740" ;;
  622.       powerpc7400 | powerpc7410)
  623.     gcc_cflags_asm="-Wa,-maltivec"
  624.     gcc_cflags_cpu="-mcpu=7400 -mcpu=750" ;;
  625.       powerpc74[45]?)
  626.     gcc_cflags_asm="-Wa,-maltivec"
  627.     gcc_cflags_cpu="-mcpu=7450" ;;
  628.       powerpc750)   gcc_cflags_cpu="-mcpu=750" ;;
  629.       powerpc801)   gcc_cflags_cpu="-mcpu=801" ;;
  630.       powerpc821)   gcc_cflags_cpu="-mcpu=821" ;;
  631.       powerpc823)   gcc_cflags_cpu="-mcpu=823" ;;
  632.       powerpc860)   gcc_cflags_cpu="-mcpu=860" ;;
  633.       powerpc970)   gcc_cflags_cpu="-mtune=970"
  634.     vmx_path="powerpc64/vmx"
  635.     cpu_path="p4" ;;
  636.       power4)     gcc_cflags_cpu="-mtune=power4"
  637.     cpu_path="p4" ;;
  638.       power5)     gcc_cflags_cpu="-mtune=power5 -mtune=power4"
  639.     cpu_path="p5 p4" ;;
  640.       power6)     gcc_cflags_cpu="-mtune=power6"
  641.     cpu_path="p6" ;;
  642.     esac
  643.     case $host in
  644.       *-*-aix*)
  645.         cclist="gcc xlc cc"
  646.         xlc_cflags="-O2 -qmaxmem=20000"
  647.         xlc_cflags_optlist="arch"
  648.         # xlc (what version?) knows -qarch=ppc, ppcgr, 601, 602, 603, 604,
  649.         # 403, rs64a
  650.         # -qarch=ppc is needed, so ensure everything falls back to that.
  651.         # FIXME: Perhaps newer versions know more flavours.
  652.         #
  653. case $host_cpu in
  654.   powerpc403)   xlc_cflags_arch="-qarch=403 -qarch=ppc" ;;
  655.   powerpc601)   xlc_cflags_arch="-qarch=601 -qarch=ppc" ;;
  656.   powerpc602)   xlc_cflags_arch="-qarch=602 -qarch=ppc" ;;
  657.   powerpc603)   xlc_cflags_arch="-qarch=603 -qarch=ppc" ;;
  658.   powerpc603e)  xlc_cflags_arch="-qarch=603 -qarch=ppc" ;;
  659.   powerpc604)   xlc_cflags_arch="-qarch=604 -qarch=ppc" ;;
  660.   powerpc604e)  xlc_cflags_arch="-qarch=604 -qarch=ppc" ;;
  661.   *)            xlc_cflags_arch="-qarch=ppc" ;;
  662.         esac
  663.         ;;
  664.     esac
  665.     case $host in
  666.       powerpc64-*-* | powerpc64le-*-* | powerpc620-*-* | powerpc630-*-* | powerpc970-*-* | power[3-9]-*-*)
  667.         case $host in
  668.           *-*-aix*)
  669.             # On AIX a true 64-bit ABI is available.
  670.             # Need -Wc to pass object type flags through to the linker.
  671.             abilist="aix64 $abilist"
  672.             cclist_aix64="gcc xlc"
  673.             gcc_aix64_cflags="-O2 -maix64 -mpowerpc64"
  674.             gcc_aix64_cflags_optlist="cpu"
  675.     gcc_aix64_ldflags="-Wc,-maix64"
  676.             xlc_aix64_cflags="-O2 -q64 -qtune=pwr3 -qmaxmem=20000"
  677.     xlc_aix64_ldflags="-Wc,-q64"
  678.             # Must indicate object type to ar and nm
  679.     ar_aix64_flags="-X64"
  680.     nm_aix64_flags="-X64"
  681.     path_aix64=""
  682.     for i in $cpu_path; do path_aix64="${path_aix64}powerpc64/mode64/$i "; done
  683.             path_aix64="${path_aix64}powerpc64/mode64 $vmx_path powerpc64"
  684.             # grab this object, though it's not a true cycle counter routine
  685.             SPEED_CYCLECOUNTER_OBJ_aix64=powerpc64.lo
  686.             cyclecounter_size_aix64=0
  687.             ;;
  688.           *-*-darwin*)
  689.             # On Darwin we can use 64-bit instructions with a longlong limb,
  690.             # but the chip still in 32-bit mode.
  691.             # In theory this can be used on any OS which knows how to save
  692.             # 64-bit registers in a context switch.
  693.             #
  694.             # Note that we must use -mpowerpc64 with gcc, since the
  695.             # longlong.h macros expect limb operands in a single 64-bit
  696.             # register, not two 32-bit registers as would be given for a
  697.             # long long without -mpowerpc64.  In theory we could detect and
  698.             # accommodate both styles, but the proper 64-bit registers will
  699.             # be fastest and are what we really want to use.
  700.             #
  701.     # One would think -mpowerpc64 would set the assembler in the right
  702.     # mode to handle 64-bit instructions.  But for that, also
  703.     # -force_cpusubtype_ALL is needed.
  704.     #
  705.     # Do not use -fast for Darwin, it actually adds options
  706.     # incompatible with a shared library.
  707.     #
  708.     abilist="mode64 mode32 $abilist"
  709.     gcc_cflags_opt="-O3 -O2 -O1" # will this become used?
  710.     cclist_mode32="gcc"
  711.     gcc_mode32_cflags="-mpowerpc64"
  712.     gcc_mode32_cflags_optlist="subtype cpu opt"
  713.     gcc_mode32_cflags_subtype="-force_cpusubtype_ALL"
  714.     gcc_mode32_cflags_opt="-O3 -O2 -O1"
  715.     path_mode32="powerpc64/mode32 $vmx_path powerpc64"
  716.     limb_mode32=longlong
  717.     cclist_mode64="gcc"
  718.     gcc_mode64_cflags="-m64"
  719.     gcc_mode64_cflags_optlist="cpu opt"
  720.     gcc_mode64_cflags_opt="-O3 -O2 -O1"
  721.     path_mode64=""
  722.     for i in $cpu_path; do path_mode64="${path_mode64}powerpc64/mode64/$i "; done
  723.     path_mode64="${path_mode64}powerpc64/mode64 $vmx_path powerpc64"
  724.             SPEED_CYCLECOUNTER_OBJ_mode64=powerpc64.lo
  725.             cyclecounter_size_mode64=0
  726.     any_mode64_testlist="sizeof-long-8"
  727.     ;;
  728.   *-*-linux* | *-*-*bsd*)
  729.     # On GNU/Linux, assume the processor is in 64-bit mode.  Some
  730.     # environments have a gcc that is always in 64-bit mode, while
  731.     # others require -m64, hence the use of cflags_maybe.  The
  732.     # sizeof-long-8 test checks the mode is right (for the no option
  733.     # case).
  734.             #
  735.             # -mpowerpc64 is not used, since it should be the default in
  736.             # 64-bit mode.  (We need its effect for the various longlong.h
  737.             # asm macros to be right of course.)
  738.             #
  739.             # gcc64 was an early port of gcc to 64-bit mode, but should be
  740.             # obsolete before too long.  We prefer plain gcc when it knows
  741.             # 64-bits.
  742.     #
  743.     abilist="mode64 mode32 $abilist"
  744.     cclist_mode32="gcc"
  745.     gcc_mode32_cflags="-mpowerpc64"
  746.     gcc_mode32_cflags_optlist="cpu opt"
  747.     gcc_mode32_cflags_opt="-O3 -O2 -O1"
  748.     path_mode32="powerpc64/mode32 $vmx_path powerpc64"
  749.     limb_mode32=longlong
  750.     cclist_mode64="gcc gcc64"
  751.     gcc_mode64_cflags_maybe="-m64"
  752.     gcc_mode64_cflags_optlist="cpu opt"
  753.     gcc_mode64_cflags_opt="-O3 -O2 -O1"
  754.     path_mode64=""
  755.     for i in $cpu_path; do path_mode64="${path_mode64}powerpc64/mode64/$i "; done
  756.     path_mode64="${path_mode64}powerpc64/mode64 $vmx_path powerpc64"
  757.             SPEED_CYCLECOUNTER_OBJ_mode64=powerpc64.lo
  758.             cyclecounter_size_mode64=0
  759.     any_mode64_testlist="sizeof-long-8"
  760.     ;;
  761.         esac
  762.         ;;
  763.     esac
  764.     ;;
  765.   # POWER
  766.   power-*-* | power[12]-*-* | power2sc-*-*)
  767.     $as_echo "#define HAVE_HOST_CPU_FAMILY_power 1" >>confdefs.h
  768.     HAVE_HOST_CPU_FAMILY_power=1
  769.     cclist="gcc"
  770.     extra_functions="udiv_w_sdiv"
  771.     path="power"
  772.     # gcc 2.7.2 knows rios1, rios2, rsc
  773.     #
  774.     # -mcpu=rios2 can tickle an AIX assembler bug (see GMP_PROG_CC_WORKS) so
  775.     # there needs to be a fallback to just -mpower.
  776.     #
  777.     gcc_cflags_optlist="cpu"
  778.     case $host in
  779.       power-*-*)    gcc_cflags_cpu="-mcpu=power -mpower" ;;
  780.       power1-*-*)   gcc_cflags_cpu="-mcpu=rios1 -mpower" ;;
  781.       power2-*-*)   gcc_cflags_cpu="-mcpu=rios2 -mpower" ;;
  782.       power2sc-*-*) gcc_cflags_cpu="-mcpu=rsc   -mpower" ;;
  783.     esac
  784.     case $host in
  785.     *-*-aix*)
  786.       cclist="gcc xlc"
  787.       xlc_cflags="-O2 -qarch=pwr -qmaxmem=20000"
  788.       ;;
  789.     esac
  790.     ;;
  791.   pyramid-*-*)
  792.     path="pyr"
  793.     ;;
  794.   # IBM s/370 and similar
  795.   s3[6-9]0*-*-*)
  796.     gcc_cflags="$gcc_cflags $fomit_frame_pointer"
  797.     path="s390"
  798.     extra_functions="udiv_w_sdiv"
  799.     ;;
  800.   sh-*-*)   path="sh" ;;
  801.   sh2-*-*)  path="sh/sh2 sh" ;;
  802.   *sparc*-*-*)
  803.     # sizeof(long)==4 or 8 is tested, to ensure we get the right ABI.  We've
  804.     # had various bug reports where users have set CFLAGS for their desired
  805.     # mode, but not set our ABI.  For some reason it's sparc where this
  806.     # keeps coming up, presumably users there are accustomed to driving the
  807.     # compiler mode that way.  The effect of our testlist setting is to
  808.     # reject ABI=64 in favour of ABI=32 if the user has forced the flags to
  809.     # 32-bit mode.
  810.     #
  811.     abilist="32"
  812.     cclist="gcc acc cc"
  813.     any_testlist="sizeof-long-4"
  814. echo "include_mpn(`sparc32/sparc-defs.m4')" >> $gmp_tmpconfigm4i
  815.     case $host_cpu in
  816.       sparcv8 | microsparc | turbosparc)
  817.         path="sparc32/v8 sparc32" ;;
  818.       supersparc)
  819.         path="sparc32/v8/supersparc sparc32/v8 sparc32" ;;
  820.       sparc64 | sparcv9* | ultrasparc*)
  821.         path="sparc32/v9 sparc32/v8 sparc32" ;;
  822.       *)
  823.         path="sparc32" ;;
  824.     esac
  825.     # gcc 2.7.2 doesn't know about v9 and doesn't pass -xarch=v8plus to the
  826.     # assembler.  Add it explicitly since the solaris assembler won't accept
  827.     # our sparc32/v9 asm code without it.  gas accepts -xarch=v8plus too, so
  828.     # it can be in the cflags unconditionally (though gas doesn't need it).
  829.     #
  830.     # gcc -m32 is needed to force 32-bit mode on a dual-ABI system, but past
  831.     # gcc doesn't know that flag, hence cflags_maybe.  Note that -m32 cannot
  832.     # be done through the optlist since the plain cflags would be run first
  833.     # and we don't want to require the default mode (whatever it is) works.
  834.     #
  835.     # Note it's gcc_32_cflags_maybe and not gcc_cflags_maybe because the
  836.     # latter would be used in the 64-bit ABI on systems like "*bsd" where
  837.     # abilist="64" only.
  838.     #
  839.     case $host_cpu in
  840.       sparc64 | sparcv9* | ultrasparc*)
  841.         gcc_cflags="$gcc_cflags -Wa,-xarch=v8plus" ;;
  842.       *)
  843.         gcc_cflags="$gcc_cflags" ;;
  844.     esac
  845.     gcc_32_cflags_maybe="-m32"
  846.     gcc_cflags_optlist="cpu"
  847.     # gcc 2.7.2 knows -mcypress, -msupersparc, -mv8, -msparclite.
  848.     # gcc 2.95 knows -mcpu= v7, hypersparc, sparclite86x, f930, f934,
  849.     #   sparclet, tsc701, v9, ultrasparc.  A warning is given that the
  850.     #   plain -m forms will disappear.
  851.     # gcc 3.0 adds nothing.
  852.     # gcc 3.1 adds nothing.
  853.     # gcc 3.2 adds nothing.
  854.     # gcc 3.3 adds ultrasparc3.
  855.     #
  856.     case $host_cpu in
  857.       supersparc)           gcc_cflags_cpu="-mcpu=supersparc -msupersparc" ;;
  858.       sparcv8 | microsparc | turbosparc)
  859.     gcc_cflags_cpu="-mcpu=v8 -mv8" ;;
  860.       sparc64 | sparcv9*)   gcc_cflags_cpu="-mcpu=v9 -mv8" ;;
  861.       ultrasparc3)          gcc_cflags_cpu="-mcpu=ultrasparc3 -mcpu=ultrasparc -mv8" ;;
  862.       ultrasparc*)          gcc_cflags_cpu="-mcpu=ultrasparc -mv8" ;;
  863.       *)                    gcc_cflags_cpu="-mcpu=v7 -mcypress" ;;
  864.     esac
  865.     # SunPRO cc and acc, and SunOS bundled cc
  866.     case $host in
  867.       *-*-solaris* | *-*-sunos*)
  868. # Note no -g, it disables all optimizations.
  869. cc_cflags=
  870. cc_cflags_optlist="opt arch cpu"
  871.         # SunOS cc doesn't know -xO4, fallback to -O2.
  872. cc_cflags_opt="-xO4 -O2"
  873.         # SunOS cc doesn't know -xarch, apparently always generating v7
  874.         # code, so make this optional
  875. case $host_cpu in
  876.   sparcv8 | microsparc | supersparc | turbosparc)
  877.       cc_cflags_arch="-xarch=v8" ;;
  878.   sparc64 | sparcv9* | ultrasparc*)   cc_cflags_arch="-xarch=v8plus" ;;
  879.   *)                                  cc_cflags_arch="-xarch=v7" ;;
  880. esac
  881.         # SunOS cc doesn't know -xchip and doesn't seem to have an equivalent.
  882. # SunPRO cc 5 recognises -xchip=generic, old, super, super2, micro,
  883. #   micro2, hyper, hyper2, powerup, ultra, ultra2, ultra2i.
  884. # SunPRO cc 6 adds -xchip=ultra2e, ultra3cu.
  885.         #
  886. # FIXME: Which of ultra, ultra2 or ultra2i is the best fallback for
  887. # ultrasparc3?
  888. #
  889. case $host_cpu in
  890.   supersparc)   cc_cflags_cpu="-xchip=super" ;;
  891.   microsparc)   cc_cflags_cpu="-xchip=micro" ;;
  892.   turbosparc)   cc_cflags_cpu="-xchip=micro2" ;;
  893.   ultrasparc)   cc_cflags_cpu="-xchip=ultra" ;;
  894.   ultrasparc2)  cc_cflags_cpu="-xchip=ultra2" ;;
  895.   ultrasparc2i) cc_cflags_cpu="-xchip=ultra2i" ;;
  896.   ultrasparc3)  cc_cflags_cpu="-xchip=ultra3 -xchip=ultra" ;;
  897.   *)            cc_cflags_cpu="-xchip=generic" ;;
  898. esac
  899.     esac
  900.     case $host_cpu in
  901.       sparc64 | sparcv9* | ultrasparc*)
  902.         case $host in
  903.           # Solaris 6 and earlier cannot run ABI=64 since it doesn't save
  904.           # registers properly, so ABI=32 is left as the only choice.
  905.           #
  906.           *-*-solaris2.[0-6] | *-*-solaris2.[0-6].*) ;;
  907.           # BSD sparc64 ports are 64-bit-only systems, so ABI=64 is the only
  908.           # choice.  In fact they need no special compiler flags, gcc -m64
  909.           # is the default, but it doesn't hurt to add it.  v9 CPUs always
  910.           # use the sparc64 port, since the plain 32-bit sparc ports don't
  911.           # run on a v9.
  912.           #
  913.           *-*-*bsd*) abilist="64" ;;
  914.           # For all other systems, we try both 64 and 32.
  915.           #
  916.           # GNU/Linux sparc64 has only recently gained a 64-bit user mode.
  917.           # In the past sparc64 meant a v9 cpu, but there were no 64-bit
  918.           # operations in user mode.  We assume that if "gcc -m64" works
  919.           # then the system is suitable.  Hopefully even if someone attempts
  920.           # to put a new gcc and/or glibc on an old system it won't run.
  921.           #
  922.           *) abilist="64 32" ;;
  923.         esac
  924. case $host_cpu in
  925.   ultrasparc | ultrasparc2 | ultrasparc2i)
  926.     path_64="sparc64/ultrasparc12 sparc64" ;;
  927.   ultrasparc3)
  928.     path_64="sparc64/ultrasparc34 sparc64/ultrasparc12 sparc64" ;;
  929.   *)
  930.     path_64="sparc64"
  931. esac
  932.         cclist_64="gcc"
  933.         any_64_testlist="sizeof-long-8"
  934.         # gcc -mptr64 is probably implied by -m64, but we're not sure if
  935.         # this was always so.  On Solaris in the past we always used both
  936.         # "-m64 -mptr64".
  937.         #
  938.         # gcc -Wa,-xarch=v9 is thought to be necessary in some cases on
  939.         # solaris, but it would seem likely that if gcc is going to generate
  940.         # 64-bit code it will have to add that option itself where needed.
  941.         # An extra copy of this option should be harmless though, but leave
  942.         # it until we're sure.  (Might want -xarch=v9a or -xarch=v9b for the
  943.         # higher cpu types instead.)
  944.         #
  945.         gcc_64_cflags="$gcc_64_cflags -m64 -mptr64"
  946.         gcc_64_ldflags="-Wc,-m64"
  947.         gcc_64_cflags_optlist="cpu"
  948.         case $host in
  949.           *-*-solaris*)
  950.             # Sun cc.
  951.             #
  952.             # We used to have -fast and some fixup options here, but it
  953.             # recurrently caused problems with miscompilation.  Of course,
  954.             # -fast is documented as miscompiling things for the sake of speed.
  955.             #
  956.             cclist_64="$cclist_64 cc"
  957.             cc_64_cflags="-xO3 -xarch=v9"
  958.             cc_64_cflags_optlist="cpu"
  959.             ;;
  960.         esac
  961.         # using the v9 %tick register
  962.         SPEED_CYCLECOUNTER_OBJ_32=sparcv9.lo
  963.         SPEED_CYCLECOUNTER_OBJ_64=sparcv9.lo
  964.         cyclecounter_size_32=2
  965.         cyclecounter_size_64=2
  966.         ;;
  967.     esac
  968.     ;;
  969.   # VAX
  970.   vax*-*-*)
  971.     # Currently gcc (version 3.0) on vax always uses a frame pointer
  972.     # (config/vax/vax.h FRAME_POINTER_REQUIRED=1), so -fomit-frame-pointer
  973.     # will be ignored.
  974.     #
  975.     gcc_cflags="$gcc_cflags $fomit_frame_pointer"
  976.     path="vax"
  977.     extra_functions="udiv_w_sdiv"
  978.     ;;
  979.   # AMD and Intel x86 configurations, including AMD64
  980.   #
  981.   # Rumour has it gcc -O2 used to give worse register allocation than just
  982.   # -O, but lets assume that's no longer true.
  983.   #
  984.   # -m32 forces 32-bit mode on a bi-arch 32/64 amd64 build of gcc.  -m64 is
  985.   # the default in such a build (we think), so -m32 is essential for ABI=32.
  986.   # This is, of course, done for any $host_cpu, not just x86_64, so we can
  987.   # get such a gcc into the right mode to cross-compile to say i486-*-*.
  988.   #
  989.   # -m32 is not available in gcc 2.95 and earlier, hence cflags_maybe to use
  990.   # it when it works.  We check sizeof(long)==4 to ensure we get the right
  991.   # mode, in case -m32 has failed not because it's an old gcc, but because
  992.   # it's a dual 32/64-bit gcc without a 32-bit libc, or whatever.
  993.   #
  994.   i?86*-*-* | k[5-8]*-*-* | pentium*-*-* | athlon-*-* | viac3*-*-* | geode*-*-* | atom-*-* | athlon64-*-* | pentium4-*-* | atom-*-* | core2-*-* | corei-*-* | x86_64-*-* | nano-*-*)
  995.     abilist="32"
  996.     cclist="gcc icc cc"
  997.     gcc_cflags="$gcc_cflags $fomit_frame_pointer"
  998.     gcc_32_cflags_maybe="-m32"
  999.     icc_cflags="-no-gcc"
  1000.     icc_cflags_optlist="opt"
  1001.     icc_cflags_opt="-O3 -O2 -O1"
  1002.     any_32_testlist="sizeof-long-4"
  1003.     CALLING_CONVENTIONS_OBJS='x86call.lo x86check$U.lo'
  1004.     # Availability of rdtsc is checked at run-time.
  1005.     SPEED_CYCLECOUNTER_OBJ=pentium.lo
  1006.     # gcc 2.7.2 only knows i386 and i486, using -m386 or -m486.  These
  1007.     #     represent -mcpu= since -m486 doesn't generate 486 specific insns.
  1008.     # gcc 2.95 adds k6, pentium and pentiumpro, and takes -march= and -mcpu=.
  1009.     # gcc 3.0 adds athlon.
  1010.     # gcc 3.1 adds k6-2, k6-3, pentium-mmx, pentium2, pentium3, pentium4,
  1011.     #     athlon-tbird, athlon-4, athlon-xp, athlon-mp.
  1012.     # gcc 3.2 adds winchip2.
  1013.     # gcc 3.3 adds winchip-c6.
  1014.     # gcc 3.3.1 from mandrake adds k8 and knows -mtune.
  1015.     # gcc 3.4 adds c3, c3-2, k8, and deprecates -mcpu in favour of -mtune.
  1016.     #
  1017.     # In gcc 2.95.[0123], -march=pentiumpro provoked a stack slot bug in an
  1018.     # old version of mpz/powm.c.  Seems to be fine with the current code, so
  1019.     # no need for any restrictions on that option.
  1020.     #
  1021.     # -march=pentiumpro can fail if the assembler doesn't know "cmov"
  1022.     # (eg. solaris 2.8 native "as"), so always have -march=pentium after
  1023.     # that as a fallback.
  1024.     #
  1025.     # -march=pentium4 and -march=k8 enable SSE2 instructions, which may or
  1026.     # may not be supported by the assembler and/or the OS, and is bad in gcc
  1027.     # prior to 3.3.  The tests will reject these if no good, so fallbacks
  1028.     # like "-march=pentium4 -mno-sse2" are given to try also without SSE2.
  1029.     # Note the relevant -march types are listed in the optflags handling
  1030.     # below, be sure to update there if adding new types emitting SSE2.
  1031.     #
  1032.     # -mtune is used at the start of each cpu option list to give something
  1033.     # gcc 3.4 will use, thereby avoiding warnings from -mcpu.  -mcpu forms
  1034.     # are retained for use by prior gcc.  For example pentium has
  1035.     # "-mtune=pentium -mcpu=pentium ...", the -mtune is for 3.4 and the
  1036.     # -mcpu for prior.  If there's a brand new choice in 3.4 for a chip,
  1037.     # like k8 for x86_64, then it can be the -mtune at the start, no need to
  1038.     # duplicate anything.
  1039.     #
  1040.     gcc_cflags_optlist="cpu arch"
  1041.     case $host_cpu in
  1042.       i386*)
  1043.         gcc_cflags_cpu="-mtune=i386 -mcpu=i386 -m386"
  1044.         gcc_cflags_arch="-march=i386"
  1045.         ;;
  1046.       i486*)
  1047.         gcc_cflags_cpu="-mtune=i486 -mcpu=i486 -m486"
  1048.         gcc_cflags_arch="-march=i486"
  1049.         ;;
  1050.       i586 | pentium)
  1051.         gcc_cflags_cpu="-mtune=pentium -mcpu=pentium -m486"
  1052.         gcc_cflags_arch="-march=pentium"
  1053.         ;;
  1054.       pentiummmx)
  1055.         gcc_cflags_cpu="-mtune=pentium-mmx -mcpu=pentium-mmx -mcpu=pentium -m486"
  1056.         gcc_cflags_arch="-march=pentium-mmx -march=pentium"
  1057.         ;;
  1058.       i686 | pentiumpro)
  1059.         gcc_cflags_cpu="-mtune=pentiumpro -mcpu=pentiumpro -mcpu=i486 -m486"
  1060.         gcc_cflags_arch="-march=pentiumpro -march=pentium"
  1061.         ;;
  1062.       pentium2)
  1063.         gcc_cflags_cpu="-mtune=pentium2 -mcpu=pentium2 -mcpu=pentiumpro -mcpu=i486 -m486"
  1064.         gcc_cflags_arch="-march=pentium2 -march=pentiumpro -march=pentium"
  1065.         ;;
  1066.       pentium3 | pentiumm)
  1067.         gcc_cflags_cpu="-mtune=pentium3 -mcpu=pentium3 -mcpu=pentiumpro -mcpu=i486 -m486"
  1068.         gcc_cflags_arch="-march=pentium3 -march=pentiumpro -march=pentium"
  1069.         ;;
  1070.       k6)
  1071.         gcc_cflags_cpu="-mtune=k6 -mcpu=k6 -mcpu=i486 -m486"
  1072.         gcc_cflags_arch="-march=k6"
  1073.         ;;
  1074.       k62)
  1075.         gcc_cflags_cpu="-mtune=k6-2 -mcpu=k6-2 -mcpu=k6 -mcpu=i486 -m486"
  1076.         gcc_cflags_arch="-march=k6-2 -march=k6"
  1077.         ;;
  1078.       k63)
  1079.         gcc_cflags_cpu="-mtune=k6-3 -mcpu=k6-3 -mcpu=k6 -mcpu=i486 -m486"
  1080.         gcc_cflags_arch="-march=k6-3 -march=k6"
  1081.         ;;
  1082.       geode)
  1083.         gcc_cflags_cpu="-mtune=k6-3 -mcpu=k6-3 -mcpu=k6 -mcpu=i486 -m486"
  1084.         gcc_cflags_arch="-march=k6-3 -march=k6"
  1085.         ;;
  1086.       athlon)
  1087.         # Athlon instruction costs are close to P6 (3 cycle load latency,
  1088.         # 4-6 cycle mul, 40 cycle div, pairable adc, etc) so if gcc doesn't
  1089.         # know athlon (eg. 2.95.2 doesn't) then fall back on pentiumpro.
  1090.         gcc_cflags_cpu="-mtune=athlon -mcpu=athlon -mcpu=pentiumpro -mcpu=i486 -m486"
  1091.         gcc_cflags_arch="-march=athlon -march=pentiumpro -march=pentium"
  1092.         ;;
  1093.       i786 | pentium4)
  1094.         # pentiumpro is the primary fallback when gcc doesn't know pentium4.
  1095.         # This gets us cmov to eliminate branches.  Maybe "athlon" would be
  1096.         # a possibility on gcc 3.0.
  1097.         #
  1098.         gcc_cflags_cpu="-mtune=pentium4 -mcpu=pentium4 -mcpu=pentiumpro -mcpu=i486 -m486"
  1099.         gcc_cflags_arch="-march=pentium4 -march=pentium4~-mno-sse2 -march=pentiumpro -march=pentium"
  1100.         gcc_64_cflags_cpu="-mtune=nocona"
  1101.         ;;
  1102.       viac32)
  1103.         # Not sure of the best fallbacks here for -mcpu.
  1104.         # c3-2 has sse and mmx, so pentium3 is good for -march.
  1105.         gcc_cflags_cpu="-mtune=c3-2 -mcpu=c3-2 -mcpu=i486 -m486"
  1106.         gcc_cflags_arch="-march=c3-2 -march=pentium3 -march=pentiumpro -march=pentium"
  1107.         ;;
  1108.       viac3*)
  1109.         # Not sure of the best fallbacks here.
  1110.         gcc_cflags_cpu="-mtune=c3 -mcpu=c3 -mcpu=i486 -m486"
  1111.         gcc_cflags_arch="-march=c3 -march=pentium-mmx -march=pentium"
  1112.         ;;
  1113.       athlon64 | x86_64)
  1114.         gcc_cflags_cpu="-mtune=k8 -mcpu=athlon -mcpu=pentiumpro -mcpu=i486 -m486"
  1115.         gcc_cflags_arch="-march=k8 -march=k8~-mno-sse2 -march=athlon -march=pentiumpro -march=pentium"
  1116.         ;;
  1117.       core2 | corei)
  1118.         gcc_cflags_cpu="-mtune=core2 -mtune=k8"
  1119.         gcc_cflags_arch="-march=core2 -march=core2~-mno-sse2 -march=k8 -march=k8~-mno-sse2"
  1120.         ;;
  1121.       atom)
  1122.         gcc_cflags_cpu="-mtune=atom -mtune=pentium3"
  1123.         gcc_cflags_arch="-march=atom -march=pentium3"
  1124.         ;;
  1125.       *)
  1126.         gcc_cflags_cpu="-mtune=i486 -mcpu=i486 -m486"
  1127.         gcc_cflags_arch="-march=i486"
  1128.         ;;
  1129.     esac
  1130.     case $host_cpu in
  1131.       i386*)                path="x86" ;;
  1132.       i486*)                path="x86/i486 x86" ;;
  1133.       i586 | pentium)       path="x86/pentium x86" ;;
  1134.       pentiummmx)           path="x86/pentium/mmx x86/pentium x86" ;;
  1135.       i686 | pentiumpro)    path="x86/p6 x86" ;;
  1136.       pentium2)             path="x86/p6/mmx x86/p6 x86" ;;
  1137.       pentium3)             path="x86/p6/p3mmx x86/p6/mmx x86/p6 x86";;
  1138.       pentiumm | core2 | corei)
  1139.                             path="x86/p6/sse2 x86/p6/p3mmx x86/p6/mmx x86/p6 x86";;
  1140.       k6[23])             path="x86/k6/k62mmx x86/k6/mmx x86/k6 x86" ;;
  1141.       k6)                   path="x86/k6/mmx x86/k6 x86" ;;
  1142.       geode)                path="x86/k6/k62mmx x86/k6/mmx x86/k6 x86" ;;
  1143.       # we don't have any specific 32-bit code for athlon64/opteron, the
  1144.       # athlon code should be reasonable
  1145.       athlon | athlon64)    path="x86/k7/mmx x86/k7 x86" ;;
  1146.       i786 | pentium4)      path="x86/pentium4/sse2 x86/pentium4/mmx x86/pentium4 x86" ;;
  1147.       # VIA/Centaur processors, sold as CyrixIII and C3.
  1148.       viac32)               path="x86/p6/p3mmx x86/p6/mmx x86/p6 x86";;
  1149.       viac3*)               path="x86/pentium/mmx x86/pentium x86";;
  1150.       atom)                 path="x86/atom x86" ;;
  1151.       *)                    path="x86" ;;
  1152.     esac
  1153.     case $host in
  1154.       athlon64-*-* | pentium4-*-* | atom-*-* | core2-*-* | corei-*-* | x86_64-*-* | nano-*-*)
  1155. cclist_64="gcc"
  1156. gcc_64_cflags="$gcc_64_cflags -m64"
  1157. gcc_64_cflags_optlist="cpu arch"
  1158. CALLING_CONVENTIONS_OBJS_64='amd64call.lo amd64check$U.lo'
  1159. SPEED_CYCLECOUNTER_OBJ_64=x86_64.lo
  1160. cyclecounter_size_64=2
  1161. abilist="64 32"
  1162. path_64="x86_64"
  1163. case $host_cpu in
  1164.   x86_64)
  1165.     ;;
  1166.   athlon64)
  1167.     path_64="x86_64/k8 $path_64"
  1168.     ;;
  1169.   pentium4)
  1170.     path_64="x86_64/pentium4 $path_64"
  1171.     ;;
  1172.   core2)
  1173.     path_64="x86_64/core2 $path_64"
  1174.     ;;
  1175.   corei)
  1176.     path_64="x86_64/corei x86_64/core2 $path_64"
  1177.     ;;
  1178.   atom)
  1179.     path_64="x86_64/atom $path_64"
  1180.     ;;
  1181.   nano)
  1182.     path_64="x86_64/nano $path_64"
  1183.     ;;
  1184. esac
  1185. case $host in
  1186.   *-*-solaris*)
  1187.     # Sun cc.
  1188.     cclist_64="$cclist_64 cc"
  1189.     cc_64_cflags="-xO3 -m64"
  1190.     ;;
  1191.   *-*-mingw*)
  1192.     limb_64=longlong
  1193.     path_64="" # Windows amd64 calling conventions are *different*
  1194.     # Silence many pedantic warnings for w64.  FIXME.
  1195.     gcc_64_cflags="$gcc_64_cflags -std=gnu99"
  1196.     ;;
  1197. esac
  1198. ;;
  1199.     esac
  1200.     ;;
  1201.   # FIXME: z8kx won't get through config.sub.  Could make 16 versus 32 bit
  1202.   # limb an ABI option perhaps.
  1203.   z8kx*-*-*)
  1204.     path="z8000x"
  1205.     extra_functions="udiv_w_sdiv"
  1206.     ;;
  1207.   z8k*-*-*)
  1208.     path="z8000"
  1209.     extra_functions="udiv_w_sdiv"
  1210.     ;;
  1211.   # Special CPU "none" selects generic C.  -DNO_ASM is used to disable gcc
  1212.   # asm blocks in longlong.h (since they're driven by cpp pre-defined
  1213.   # symbols like __alpha rather than the configured $host_cpu).
  1214.   #
  1215.   none-*-*)
  1216.     abilist="long longlong"
  1217.     cclist_long=$cclist
  1218.     gcc_long_cflags=$gcc_cflags
  1219.     gcc_long_cppflags="-DNO_ASM"
  1220.     cc_long_cflags=$cc_cflags
  1221.     cclist_longlong=$cclist
  1222.     gcc_longlong_cflags=$gcc_cflags
  1223.     gcc_longlong_cppflags="-DNO_ASM"
  1224.     cc_longlong_cflags=$cc_cflags
  1225.     limb_longlong=longlong
  1226.     ;;
  1227. esac
  1228. # mingw can be built by the cygwin gcc if -mno-cygwin is added.  For
  1229. # convenience add this automatically if it works.  Actual mingw gcc accepts
  1230. # -mno-cygwin too, but of course is the default.  mingw only runs on the
  1231. # x86s, but allow any CPU here so as to catch "none" too.
  1232. #
  1233. case $host in
  1234.   *-*-mingw*)
  1235.     gcc_cflags_optlist="$gcc_cflags_optlist nocygwin"
  1236.     gcc_cflags_nocygwin="-mno-cygwin"
  1237.     ;;
  1238. esac
  1239. CFLAGS_or_unset=${CFLAGS-'(unset)'}
  1240. CPPFLAGS_or_unset=${CPPFLAGS-'(unset)'}
  1241. cat >&5 <<EOF
  1242. User:
  1243. ABI=$ABI
  1244. CC=$CC
  1245. CFLAGS=$CFLAGS_or_unset
  1246. CPPFLAGS=$CPPFLAGS_or_unset
  1247. MPN_PATH=$MPN_PATH
  1248. GMP:
  1249. abilist=$abilist
  1250. cclist=$cclist
  1251. EOF
  1252. test_CFLAGS=${CFLAGS+set}
  1253. test_CPPFLAGS=${CPPFLAGS+set}
  1254. for abi in $abilist; do
  1255.   abi_last="$abi"
  1256. done
  1257. # If the user specifies an ABI then it must be in $abilist, after that
  1258. # $abilist is restricted to just that choice.
  1259. #
  1260. if test -n "$ABI"; then
  1261.   found=no
  1262.   for abi in $abilist; do
  1263.     if test $abi = "$ABI"; then found=yes; break; fi
  1264.   done
  1265.   if test $found = no; then
  1266.     as_fn_error "ABI=$ABI is not among the following valid choices: $abilist" "$LINENO" 5
  1267.   fi
  1268.   abilist="$ABI"
  1269. fi
  1270. found_compiler=no
  1271. for abi in $abilist; do
  1272.   echo "checking ABI=$abi"
  1273.   # Suppose abilist="64 32", then for abi=64, will have abi1="_64" and
  1274.   # abi2="_64".  For abi=32, will have abi1="_32" and abi2="".  This is how
  1275.   # $gcc_cflags becomes a fallback for $gcc_32_cflags (the last in the
  1276.   # abilist), but there's no fallback for $gcc_64_cflags.
  1277.   #
  1278.   abi1=`echo _$abi | sed 's/[.]//g'`
  1279.   if test $abi = $abi_last; then abi2=; else abi2="$abi1"; fi
  1280.   # Compiler choices under this ABI
  1281.                               eval cclist_chosen="$cclist$abi1"
  1282.   test -n "$cclist_chosen" || eval cclist_chosen="$cclist$abi2"
  1283.   # If there's a user specified $CC then don't use a list for
  1284.   # $cclist_chosen, just a single value for $ccbase.
  1285.   #
  1286.   if test -n "$CC"; then
  1287.     # The first word of $CC, stripped of any directory.  For instance
  1288.     # CC="/usr/local/bin/gcc -pipe" will give "gcc".
  1289.     #
  1290.     for ccbase in $CC; do break; done
  1291.     ccbase=`echo $ccbase | sed 's:.*/::'`
  1292.     # If this $ccbase is in $cclist_chosen then it's a compiler we know and
  1293.     # we can do flags defaulting with it.  If not, then $cclist_chosen is
  1294.     # set to "unrecognised" so no default flags are used.
  1295.     #
  1296.     # "unrecognised" is used to avoid bad effects with eval if $ccbase has
  1297.     # non-symbol characters.  For instance ccbase=my+cc would end up with
  1298.     # something like cflags="$my+cc_cflags" which would give
  1299.     # cflags="+cc_cflags" rather than the intended empty string for an
  1300.     # unknown compiler.
  1301.     #
  1302.     found=unrecognised
  1303.     for i in $cclist_chosen; do
  1304.       if test "$ccbase" = $i; then
  1305.         found=$ccbase
  1306.         break
  1307.       fi
  1308.     done
  1309.     cclist_chosen=$found
  1310.   fi
  1311.   for ccbase in $cclist_chosen; do
  1312.     # When cross compiling, look for a compiler with the $host_alias as a
  1313.     # prefix, the same way that AC_CHECK_TOOL does.  But don't do this to a
  1314.     # user-selected $CC.
  1315.     #
  1316.     # $cross_compiling will be yes/no/maybe at this point.  Do the host
  1317.     # prefixing for "maybe" as well as "yes".
  1318.     #
  1319.     if test "$cross_compiling" != no && test -z "$CC"; then
  1320.       cross_compiling_prefix="${host_alias}-"
  1321.     fi
  1322.     for ccprefix in $cross_compiling_prefix ""; do
  1323.       cc="$CC"
  1324.       test -n "$cc" || cc="$ccprefix$ccbase"
  1325.       # If the compiler is gcc but installed under another name, then change
  1326.       # $ccbase so as to use the flags we know for gcc.  This helps for
  1327.       # instance when specifying CC=gcc272 on Debian GNU/Linux, or the
  1328.       # native cc which is really gcc on NeXT or MacOS-X.
  1329.       #
  1330.       # FIXME: There's a slight misfeature here.  If cc is actually gcc but
  1331.       # gcc is not a known compiler under this $abi then we'll end up
  1332.       # testing it with no flags and it'll work, but chances are it won't be
  1333.       # in the right mode for the ABI we desire.  Let's quietly hope this
  1334.       # doesn't happen.
  1335.       #
  1336.       if test $ccbase != gcc; then
  1337.         cat >conftest.c <<EOF
  1338. #if ! defined (__GNUC__) || defined (__INTEL_COMPILER)
  1339.   choke me
  1340. #endif
  1341. EOF
  1342. gmp_compile="$cc -c conftest.c >&5"
  1343. if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  1344.   (eval $gmp_compile) 2>&5
  1345.   ac_status=$?
  1346.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  1347.   test $ac_status = 0; }; then
  1348.   rm -f conftest*
  1349.   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $cc is gcc" >&5
  1350. $as_echo_n "checking whether $cc is gcc... " >&6; }
  1351.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
  1352. $as_echo "yes" >&6; }
  1353.   ccbase=gcc
  1354. else
  1355.   rm -f conftest*
  1356.   :
  1357. fi
  1358.       fi
  1359.       # Similarly if the compiler is IBM xlc but invoked as cc or whatever
  1360.       # then change $ccbase and make the default xlc flags available.
  1361.       if test $ccbase != xlc; then
  1362.         gmp_command="$cc 2>&1 | grep xlc >/dev/null"
  1363. if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_command""; } >&5
  1364.   (eval $gmp_command) 2>&5
  1365.   ac_status=$?
  1366.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  1367.   test $ac_status = 0; }; then
  1368.   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $cc is xlc" >&5
  1369. $as_echo_n "checking whether $cc is xlc... " >&6; }
  1370.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
  1371. $as_echo "yes" >&6; }
  1372.   ccbase=xlc
  1373. else
  1374.   :
  1375. fi
  1376.       fi
  1377.       # acc was Sun's first unbundled compiler back in the SunOS days, or
  1378.       # something like that, but today its man page says it's not meant to
  1379.       # be used directly (instead via /usr/ucb/cc).  The options are pretty
  1380.       # much the same as the main SunPRO cc, so share those configs.
  1381.       #
  1382.       case $host in
  1383.         *sparc*-*-solaris* | *sparc*-*-sunos*)
  1384.           if test "$ccbase" = acc; then ccbase=cc; fi ;;
  1385.       esac
  1386.       for tmp_cflags_maybe in yes no; do
  1387.                              eval cflags="$${ccbase}${abi1}_cflags"
  1388.         test -n "$cflags" || eval cflags="$${ccbase}${abi2}_cflags"
  1389. if test "$tmp_cflags_maybe" = yes; then
  1390.           # don't try cflags_maybe when the user set CFLAGS
  1391.           if test "$test_CFLAGS" = set; then continue; fi
  1392.                                      eval cflags_maybe="$${ccbase}${abi1}_cflags_maybe"
  1393.           test -n "$cflags_maybe" || eval cflags_maybe="$${ccbase}${abi2}_cflags_maybe"
  1394.           # don't try cflags_maybe if there's nothing set
  1395.           if test -z "$cflags_maybe"; then continue; fi
  1396.           cflags="$cflags_maybe $cflags"
  1397.         fi
  1398.         # Any user CFLAGS, even an empty string, takes precedence
  1399.         if test "$test_CFLAGS" = set; then cflags=$CFLAGS; fi
  1400.         # Any user CPPFLAGS, even an empty string, takes precedence
  1401.                                eval cppflags="$${ccbase}${abi1}_cppflags"
  1402.         test -n "$cppflags" || eval cppflags="$${ccbase}${abi2}_cppflags"
  1403.         if test "$test_CPPFLAGS" = set; then cppflags=$CPPFLAGS; fi
  1404.         # --enable-profiling adds -p/-pg even to user-specified CFLAGS.
  1405.         # This is convenient, but it's perhaps a bit naughty to modify user
  1406.         # CFLAGS.
  1407.         case "$enable_profiling" in
  1408.           prof)       cflags="$cflags -p" ;;
  1409.           gprof)      cflags="$cflags -pg" ;;
  1410.           instrument) cflags="$cflags -finstrument-functions" ;;
  1411.         esac
  1412.         { $as_echo "$as_me:${as_lineno-$LINENO}: checking compiler $cc $cflags $cppflags" >&5
  1413. $as_echo_n "checking compiler $cc $cflags $cppflags... " >&6; }
  1414. gmp_prog_cc_works=yes
  1415. # first see a simple "main()" works, then go on to other checks
  1416. if test "$gmp_prog_cc_works" = yes; then
  1417.   # remove anything that might look like compiler output to our "||" expression
  1418.   rm -f conftest* a.out b.out a.exe a_out.exe
  1419.   cat >conftest.c <<EOF
  1420. int main () { return 0; }
  1421. EOF
  1422.   echo "Test compile: " >&5
  1423.   gmp_compile="$cc $cflags $cppflags conftest.c >&5"
  1424.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  1425.   (eval $gmp_compile) 2>&5
  1426.   ac_status=$?
  1427.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  1428.   test $ac_status = 0; }; then
  1429.     cc_works_part=yes
  1430.     if test "$cross_compiling" = no; then
  1431.       if { ac_try='./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest'
  1432.   { { eval echo ""$as_me":${as_lineno-$LINENO}: "$ac_try""; } >&5
  1433.   (eval $ac_try) 2>&5
  1434.   ac_status=$?
  1435.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  1436.   test $ac_status = 0; }; }; then :;
  1437.       else
  1438.         cc_works_part=norun
  1439.       fi
  1440.     fi
  1441.   else
  1442.     cc_works_part=no
  1443.   fi
  1444.   if test "$cc_works_part" != yes; then
  1445.     echo "failed program was:" >&5
  1446.     cat conftest.c >&5
  1447.   fi
  1448.   rm -f conftest* a.out b.out a.exe a_out.exe
  1449.   case $cc_works_part in
  1450.     yes)
  1451.       ;;
  1452.     no)
  1453.       gmp_prog_cc_works="no"
  1454.       ;;
  1455.     norun)
  1456.       gmp_prog_cc_works="no, program does not run"
  1457.       ;;
  1458.   esac
  1459. fi
  1460. if test "$gmp_prog_cc_works" = yes; then
  1461.   # remove anything that might look like compiler output to our "||" expression
  1462.   rm -f conftest* a.out b.out a.exe a_out.exe
  1463.   cat >conftest.c <<EOF
  1464. /* The following provokes an internal error from gcc 2.95.2 -mpowerpc64
  1465.    (without -maix64), hence detecting an unusable compiler */
  1466. void *g() { return (void *) 0; }
  1467. void *f() { return g(); }
  1468. int main () { return 0; }
  1469. EOF
  1470.   echo "Test compile: function pointer return" >&5
  1471.   gmp_compile="$cc $cflags $cppflags conftest.c >&5"
  1472.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  1473.   (eval $gmp_compile) 2>&5
  1474.   ac_status=$?
  1475.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  1476.   test $ac_status = 0; }; then
  1477.     cc_works_part=yes
  1478.     if test "$cross_compiling" = no; then
  1479.       if { ac_try='./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest'
  1480.   { { eval echo ""$as_me":${as_lineno-$LINENO}: "$ac_try""; } >&5
  1481.   (eval $ac_try) 2>&5
  1482.   ac_status=$?
  1483.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  1484.   test $ac_status = 0; }; }; then :;
  1485.       else
  1486.         cc_works_part=norun
  1487.       fi
  1488.     fi
  1489.   else
  1490.     cc_works_part=no
  1491.   fi
  1492.   if test "$cc_works_part" != yes; then
  1493.     echo "failed program was:" >&5
  1494.     cat conftest.c >&5
  1495.   fi
  1496.   rm -f conftest* a.out b.out a.exe a_out.exe
  1497.   case $cc_works_part in
  1498.     yes)
  1499.       ;;
  1500.     no)
  1501.       gmp_prog_cc_works="no, function pointer return"
  1502.       ;;
  1503.     norun)
  1504.       gmp_prog_cc_works="no, function pointer return, program does not run"
  1505.       ;;
  1506.   esac
  1507. fi
  1508. if test "$gmp_prog_cc_works" = yes; then
  1509.   # remove anything that might look like compiler output to our "||" expression
  1510.   rm -f conftest* a.out b.out a.exe a_out.exe
  1511.   cat >conftest.c <<EOF
  1512. /* The following provokes an invalid instruction syntax from i386 gcc
  1513.    -march=pentiumpro on Solaris 2.8.  The native sun assembler
  1514.    requires a non-standard syntax for cmov which gcc (as of 2.95.2 at
  1515.    least) doesn't know.  */
  1516. int n;
  1517. int cmov () { return (n >= 0 ? n : 0); }
  1518. int main () { return 0; }
  1519. EOF
  1520.   echo "Test compile: cmov instruction" >&5
  1521.   gmp_compile="$cc $cflags $cppflags conftest.c >&5"
  1522.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  1523.   (eval $gmp_compile) 2>&5
  1524.   ac_status=$?
  1525.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  1526.   test $ac_status = 0; }; then
  1527.     cc_works_part=yes
  1528.     if test "$cross_compiling" = no; then
  1529.       if { ac_try='./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest'
  1530.   { { eval echo ""$as_me":${as_lineno-$LINENO}: "$ac_try""; } >&5
  1531.   (eval $ac_try) 2>&5
  1532.   ac_status=$?
  1533.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  1534.   test $ac_status = 0; }; }; then :;
  1535.       else
  1536.         cc_works_part=norun
  1537.       fi
  1538.     fi
  1539.   else
  1540.     cc_works_part=no
  1541.   fi
  1542.   if test "$cc_works_part" != yes; then
  1543.     echo "failed program was:" >&5
  1544.     cat conftest.c >&5
  1545.   fi
  1546.   rm -f conftest* a.out b.out a.exe a_out.exe
  1547.   case $cc_works_part in
  1548.     yes)
  1549.       ;;
  1550.     no)
  1551.       gmp_prog_cc_works="no, cmov instruction"
  1552.       ;;
  1553.     norun)
  1554.       gmp_prog_cc_works="no, cmov instruction, program does not run"
  1555.       ;;
  1556.   esac
  1557. fi
  1558. if test "$gmp_prog_cc_works" = yes; then
  1559.   # remove anything that might look like compiler output to our "||" expression
  1560.   rm -f conftest* a.out b.out a.exe a_out.exe
  1561.   cat >conftest.c <<EOF
  1562. /* The following provokes a linker invocation problem with gcc 3.0.3
  1563.    on AIX 4.3 under "-maix64 -mpowerpc64 -mcpu=630".  The -mcpu=630
  1564.    option causes gcc to incorrectly select the 32-bit libgcc.a, not
  1565.    the 64-bit one, and consequently it misses out on the __fixunsdfdi
  1566.    helper (double -> uint64 conversion).  */
  1567. double d;
  1568. unsigned long gcc303 () { return (unsigned long) d; }
  1569. int main () { return 0; }
  1570. EOF
  1571.   echo "Test compile: double -> ulong conversion" >&5
  1572.   gmp_compile="$cc $cflags $cppflags conftest.c >&5"
  1573.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  1574.   (eval $gmp_compile) 2>&5
  1575.   ac_status=$?
  1576.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  1577.   test $ac_status = 0; }; then
  1578.     cc_works_part=yes
  1579.     if test "$cross_compiling" = no; then
  1580.       if { ac_try='./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest'
  1581.   { { eval echo ""$as_me":${as_lineno-$LINENO}: "$ac_try""; } >&5
  1582.   (eval $ac_try) 2>&5
  1583.   ac_status=$?
  1584.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  1585.   test $ac_status = 0; }; }; then :;
  1586.       else
  1587.         cc_works_part=norun
  1588.       fi
  1589.     fi
  1590.   else
  1591.     cc_works_part=no
  1592.   fi
  1593.   if test "$cc_works_part" != yes; then
  1594.     echo "failed program was:" >&5
  1595.     cat conftest.c >&5
  1596.   fi
  1597.   rm -f conftest* a.out b.out a.exe a_out.exe
  1598.   case $cc_works_part in
  1599.     yes)
  1600.       ;;
  1601.     no)
  1602.       gmp_prog_cc_works="no, double -> ulong conversion"
  1603.       ;;
  1604.     norun)
  1605.       gmp_prog_cc_works="no, double -> ulong conversion, program does not run"
  1606.       ;;
  1607.   esac
  1608. fi
  1609. if test "$gmp_prog_cc_works" = yes; then
  1610.   # remove anything that might look like compiler output to our "||" expression
  1611.   rm -f conftest* a.out b.out a.exe a_out.exe
  1612.   cat >conftest.c <<EOF
  1613. /* The following provokes an error from hppa gcc 2.95 under -mpa-risc-2-0 if
  1614.    the assembler doesn't know hppa 2.0 instructions.  fneg is a 2.0
  1615.    instruction, and a negation like this comes out using it.  */
  1616. double fneg_data;
  1617. unsigned long fneg () { return -fneg_data; }
  1618. int main () { return 0; }
  1619. EOF
  1620.   echo "Test compile: double negation" >&5
  1621.   gmp_compile="$cc $cflags $cppflags conftest.c >&5"
  1622.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  1623.   (eval $gmp_compile) 2>&5
  1624.   ac_status=$?
  1625.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  1626.   test $ac_status = 0; }; then
  1627.     cc_works_part=yes
  1628.     if test "$cross_compiling" = no; then
  1629.       if { ac_try='./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest'
  1630.   { { eval echo ""$as_me":${as_lineno-$LINENO}: "$ac_try""; } >&5
  1631.   (eval $ac_try) 2>&5
  1632.   ac_status=$?
  1633.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  1634.   test $ac_status = 0; }; }; then :;
  1635.       else
  1636.         cc_works_part=norun
  1637.       fi
  1638.     fi
  1639.   else
  1640.     cc_works_part=no
  1641.   fi
  1642.   if test "$cc_works_part" != yes; then
  1643.     echo "failed program was:" >&5
  1644.     cat conftest.c >&5
  1645.   fi
  1646.   rm -f conftest* a.out b.out a.exe a_out.exe
  1647.   case $cc_works_part in
  1648.     yes)
  1649.       ;;
  1650.     no)
  1651.       gmp_prog_cc_works="no, double negation"
  1652.       ;;
  1653.     norun)
  1654.       gmp_prog_cc_works="no, double negation, program does not run"
  1655.       ;;
  1656.   esac
  1657. fi
  1658. if test "$gmp_prog_cc_works" = yes; then
  1659.   # remove anything that might look like compiler output to our "||" expression
  1660.   rm -f conftest* a.out b.out a.exe a_out.exe
  1661.   cat >conftest.c <<EOF
  1662. /* The following makes gcc 3.3 -march=pentium4 generate an SSE2 xmm insn
  1663.    (cvtsd2ss) which will provoke an error if the assembler doesn't recognise
  1664.    those instructions.  Not sure how much of the gmp code will come out
  1665.    wanting sse2, but it's easiest to reject an option we know is bad.  */
  1666. double ftod_data;
  1667. float ftod () { return (float) ftod_data; }
  1668. int main () { return 0; }
  1669. EOF
  1670.   echo "Test compile: double -> float conversion" >&5
  1671.   gmp_compile="$cc $cflags $cppflags conftest.c >&5"
  1672.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  1673.   (eval $gmp_compile) 2>&5
  1674.   ac_status=$?
  1675.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  1676.   test $ac_status = 0; }; then
  1677.     cc_works_part=yes
  1678.     if test "$cross_compiling" = no; then
  1679.       if { ac_try='./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest'
  1680.   { { eval echo ""$as_me":${as_lineno-$LINENO}: "$ac_try""; } >&5
  1681.   (eval $ac_try) 2>&5
  1682.   ac_status=$?
  1683.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  1684.   test $ac_status = 0; }; }; then :;
  1685.       else
  1686.         cc_works_part=norun
  1687.       fi
  1688.     fi
  1689.   else
  1690.     cc_works_part=no
  1691.   fi
  1692.   if test "$cc_works_part" != yes; then
  1693.     echo "failed program was:" >&5
  1694.     cat conftest.c >&5
  1695.   fi
  1696.   rm -f conftest* a.out b.out a.exe a_out.exe
  1697.   case $cc_works_part in
  1698.     yes)
  1699.       ;;
  1700.     no)
  1701.       gmp_prog_cc_works="no, double -> float conversion"
  1702.       ;;
  1703.     norun)
  1704.       gmp_prog_cc_works="no, double -> float conversion, program does not run"
  1705.       ;;
  1706.   esac
  1707. fi
  1708. if test "$gmp_prog_cc_works" = yes; then
  1709.   # remove anything that might look like compiler output to our "||" expression
  1710.   rm -f conftest* a.out b.out a.exe a_out.exe
  1711.   cat >conftest.c <<EOF
  1712. /* The following provokes an internal compiler error from gcc version
  1713.    "2.9-gnupro-99r1" under "-O2 -mcpu=ev6", apparently relating to char
  1714.    values being spilled into floating point registers.  The problem doesn't
  1715.    show up all the time, but has occurred enough in GMP for us to reject
  1716.    this compiler+flags.  */
  1717. #include <string.h>  /* for memcpy */
  1718. struct try_t
  1719. {
  1720.  char dst[2];
  1721.  char size;
  1722.  long d0, d1, d2, d3, d4, d5, d6;
  1723.  char overlap;
  1724. };
  1725. struct try_t param[6];
  1726. int
  1727. param_init ()
  1728. {
  1729.  struct try_t *p;
  1730.  memcpy (p, &param[ 2 ], sizeof (*p));
  1731.  memcpy (p, &param[ 2 ], sizeof (*p));
  1732.  p->size = 2;
  1733.  memcpy (p, &param[ 1 ], sizeof (*p));
  1734.  p->dst[0] = 1;
  1735.  p->overlap = 2;
  1736.  memcpy (p, &param[ 3 ], sizeof (*p));
  1737.  p->dst[0] = 1;
  1738.  p->overlap = 8;
  1739.  memcpy (p, &param[ 4 ], sizeof (*p));
  1740.  memcpy (p, &param[ 4 ], sizeof (*p));
  1741.  p->overlap = 8;
  1742.  memcpy (p, &param[ 5 ], sizeof (*p));
  1743.  memcpy (p, &param[ 5 ], sizeof (*p));
  1744.  memcpy (p, &param[ 5 ], sizeof (*p));
  1745.  return 0;
  1746. }
  1747. int main () { return 0; }
  1748. EOF
  1749.   echo "Test compile: gnupro alpha ev6 char spilling" >&5
  1750.   gmp_compile="$cc $cflags $cppflags conftest.c >&5"
  1751.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  1752.   (eval $gmp_compile) 2>&5
  1753.   ac_status=$?
  1754.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  1755.   test $ac_status = 0; }; then
  1756.     cc_works_part=yes
  1757.     if test "$cross_compiling" = no; then
  1758.       if { ac_try='./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest'
  1759.   { { eval echo ""$as_me":${as_lineno-$LINENO}: "$ac_try""; } >&5
  1760.   (eval $ac_try) 2>&5
  1761.   ac_status=$?
  1762.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  1763.   test $ac_status = 0; }; }; then :;
  1764.       else
  1765.         cc_works_part=norun
  1766.       fi
  1767.     fi
  1768.   else
  1769.     cc_works_part=no
  1770.   fi
  1771.   if test "$cc_works_part" != yes; then
  1772.     echo "failed program was:" >&5
  1773.     cat conftest.c >&5
  1774.   fi
  1775.   rm -f conftest* a.out b.out a.exe a_out.exe
  1776.   case $cc_works_part in
  1777.     yes)
  1778.       ;;
  1779.     no)
  1780.       gmp_prog_cc_works="no, gnupro alpha ev6 char spilling"
  1781.       ;;
  1782.     norun)
  1783.       gmp_prog_cc_works="no, gnupro alpha ev6 char spilling, program does not run"
  1784.       ;;
  1785.   esac
  1786. fi
  1787. # __builtin_alloca is not available everywhere, check it exists before
  1788. # seeing that it works
  1789. if test "$gmp_prog_cc_works" = yes; then
  1790.   # remove anything that might look like compiler output to our "||" expression
  1791.   rm -f conftest* a.out b.out a.exe a_out.exe
  1792.   cat >conftest.c <<EOF
  1793. int k; int foo () { __builtin_alloca (k); }
  1794. EOF
  1795.   echo "Test compile: __builtin_alloca availability" >&5
  1796.   gmp_compile="$cc $cflags $cppflags conftest.c >&5"
  1797.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  1798.   (eval $gmp_compile) 2>&5
  1799.   ac_status=$?
  1800.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  1801.   test $ac_status = 0; }; then
  1802.     cc_works_part=yes
  1803.     if test "$cross_compiling" = no; then
  1804.       if { ac_try='./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest'
  1805.   { { eval echo ""$as_me":${as_lineno-$LINENO}: "$ac_try""; } >&5
  1806.   (eval $ac_try) 2>&5
  1807.   ac_status=$?
  1808.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  1809.   test $ac_status = 0; }; }; then :;
  1810.       else
  1811.         cc_works_part=norun
  1812.       fi
  1813.     fi
  1814.   else
  1815.     cc_works_part=no
  1816.   fi
  1817.   if test "$cc_works_part" != yes; then
  1818.     echo "failed program was:" >&5
  1819.     cat conftest.c >&5
  1820.   fi
  1821.   rm -f conftest* a.out b.out a.exe a_out.exe
  1822.   case $cc_works_part in
  1823.     yes)
  1824.       if test "$gmp_prog_cc_works" = yes; then
  1825.   # remove anything that might look like compiler output to our "||" expression
  1826.   rm -f conftest* a.out b.out a.exe a_out.exe
  1827.   cat >conftest.c <<EOF
  1828. /* The following provokes an internal compiler error from Itanium HP-UX cc
  1829.     under +O2 or higher.  We use this sort of code in mpn/generic/mul_fft.c. */
  1830. int k;
  1831. int foo ()
  1832. {
  1833.   int i, **a;
  1834.   a = __builtin_alloca (k);
  1835.   for (i = 0; i <= k; i++)
  1836.     a[i] = __builtin_alloca (1 << i);
  1837. }
  1838. int main () { return 0; }
  1839. EOF
  1840.   echo "Test compile: alloca array" >&5
  1841.   gmp_compile="$cc $cflags $cppflags conftest.c >&5"
  1842.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  1843.   (eval $gmp_compile) 2>&5
  1844.   ac_status=$?
  1845.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  1846.   test $ac_status = 0; }; then
  1847.     cc_works_part=yes
  1848.     if test "$cross_compiling" = no; then
  1849.       if { ac_try='./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest'
  1850.   { { eval echo ""$as_me":${as_lineno-$LINENO}: "$ac_try""; } >&5
  1851.   (eval $ac_try) 2>&5
  1852.   ac_status=$?
  1853.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  1854.   test $ac_status = 0; }; }; then :;
  1855.       else
  1856.         cc_works_part=norun
  1857.       fi
  1858.     fi
  1859.   else
  1860.     cc_works_part=no
  1861.   fi
  1862.   if test "$cc_works_part" != yes; then
  1863.     echo "failed program was:" >&5
  1864.     cat conftest.c >&5
  1865.   fi
  1866.   rm -f conftest* a.out b.out a.exe a_out.exe
  1867.   case $cc_works_part in
  1868.     yes)
  1869.       ;;
  1870.     no)
  1871.       gmp_prog_cc_works="no, alloca array"
  1872.       ;;
  1873.     norun)
  1874.       gmp_prog_cc_works="no, alloca array, program does not run"
  1875.       ;;
  1876.   esac
  1877. fi
  1878.       ;;
  1879.     no)
  1880.       ;;
  1881.     norun)
  1882.       ;;
  1883.   esac
  1884. fi
  1885. if test "$gmp_prog_cc_works" = yes; then
  1886.   # remove anything that might look like compiler output to our "||" expression
  1887.   rm -f conftest* a.out b.out a.exe a_out.exe
  1888.   cat >conftest.c <<EOF
  1889. /* The following provokes an internal error from the assembler on
  1890.    power2-ibm-aix4.3.1.0.  gcc -mrios2 compiles to nabs+fcirz, and this
  1891.    results in "Internal error related to the source program domain".
  1892.    For reference it seems to be the combination of nabs+fcirz which is bad,
  1893.    not either alone.  This sort of thing occurs in mpz/get_str.c with the
  1894.    way double chars_per_bit_exactly is applied in MPN_SIZEINBASE.  Perhaps
  1895.    if that code changes to a scaled-integer style then we won't need this
  1896.    test.  */
  1897. double fp[1];
  1898. int x;
  1899. int f ()
  1900. {
  1901.   int a;
  1902.   a = (x >= 0 ? x : -x);
  1903.   return a * fp[0];
  1904. }
  1905. int main () { return 0; }
  1906. EOF
  1907.   echo "Test compile: abs int -> double conversion" >&5
  1908.   gmp_compile="$cc $cflags $cppflags conftest.c >&5"
  1909.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  1910.   (eval $gmp_compile) 2>&5
  1911.   ac_status=$?
  1912.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  1913.   test $ac_status = 0; }; then
  1914.     cc_works_part=yes
  1915.     if test "$cross_compiling" = no; then
  1916.       if { ac_try='./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest'
  1917.   { { eval echo ""$as_me":${as_lineno-$LINENO}: "$ac_try""; } >&5
  1918.   (eval $ac_try) 2>&5
  1919.   ac_status=$?
  1920.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  1921.   test $ac_status = 0; }; }; then :;
  1922.       else
  1923.         cc_works_part=norun
  1924.       fi
  1925.     fi
  1926.   else
  1927.     cc_works_part=no
  1928.   fi
  1929.   if test "$cc_works_part" != yes; then
  1930.     echo "failed program was:" >&5
  1931.     cat conftest.c >&5
  1932.   fi
  1933.   rm -f conftest* a.out b.out a.exe a_out.exe
  1934.   case $cc_works_part in
  1935.     yes)
  1936.       ;;
  1937.     no)
  1938.       gmp_prog_cc_works="no, abs int -> double conversion"
  1939.       ;;
  1940.     norun)
  1941.       gmp_prog_cc_works="no, abs int -> double conversion, program does not run"
  1942.       ;;
  1943.   esac
  1944. fi
  1945. if test "$gmp_prog_cc_works" = yes; then
  1946.   # remove anything that might look like compiler output to our "||" expression
  1947.   rm -f conftest* a.out b.out a.exe a_out.exe
  1948.   cat >conftest.c <<EOF
  1949. /* The following provokes a segfault in the compiler on powerpc-apple-darwin.
  1950.    Extracted from tests/mpn/t-iord_u.c.  Causes Apple's gcc 3.3 build 1640 and
  1951.    1666 to segfault with e.g., -O2 -mpowerpc64.  */
  1952. #if defined (__GNUC__) && ! defined (__cplusplus)
  1953. typedef unsigned long long t1;typedef t1*t2;
  1954. static __inline__ t1 e(t2 rp,t2 up,int n,t1 v0)
  1955. {t1 c,x,r;int i;if(v0){c=1;for(i=1;i<n;i++){x=up[i];r=x+1;rp[i]=r;}}return c;}
  1956. f(){static const struct{t1 n;t1 src[9];t1 want[9];}d[]={{1,{0},{1}},};t1 got[9];int i;
  1957. for(i=0;i<1;i++){if(e(got,got,9,d[i].n)==0)h();g(i,d[i].src,d[i].n,got,d[i].want,9);if(d[i].n)h();}}
  1958. h(){}g(){}
  1959. #else
  1960. int dummy;
  1961. #endif
  1962. int main () { return 0; }
  1963. EOF
  1964.   echo "Test compile: long long reliability test 1" >&5
  1965.   gmp_compile="$cc $cflags $cppflags conftest.c >&5"
  1966.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  1967.   (eval $gmp_compile) 2>&5
  1968.   ac_status=$?
  1969.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  1970.   test $ac_status = 0; }; then
  1971.     cc_works_part=yes
  1972.     if test "$cross_compiling" = no; then
  1973.       if { ac_try='./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest'
  1974.   { { eval echo ""$as_me":${as_lineno-$LINENO}: "$ac_try""; } >&5
  1975.   (eval $ac_try) 2>&5
  1976.   ac_status=$?
  1977.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  1978.   test $ac_status = 0; }; }; then :;
  1979.       else
  1980.         cc_works_part=norun
  1981.       fi
  1982.     fi
  1983.   else
  1984.     cc_works_part=no
  1985.   fi
  1986.   if test "$cc_works_part" != yes; then
  1987.     echo "failed program was:" >&5
  1988.     cat conftest.c >&5
  1989.   fi
  1990.   rm -f conftest* a.out b.out a.exe a_out.exe
  1991.   case $cc_works_part in
  1992.     yes)
  1993.       ;;
  1994.     no)
  1995.       gmp_prog_cc_works="no, long long reliability test 1"
  1996.       ;;
  1997.     norun)
  1998.       gmp_prog_cc_works="no, long long reliability test 1, program does not run"
  1999.       ;;
  2000.   esac
  2001. fi
  2002. if test "$gmp_prog_cc_works" = yes; then
  2003.   # remove anything that might look like compiler output to our "||" expression
  2004.   rm -f conftest* a.out b.out a.exe a_out.exe
  2005.   cat >conftest.c <<EOF
  2006. /* The following provokes an internal compiler error on powerpc-apple-darwin.
  2007.    Extracted from mpz/cfdiv_q_2exp.c.  Causes Apple's gcc 3.3 build 1640 and
  2008.    1666 to get an ICE with -O1 -mpowerpc64.  */
  2009. #if defined (__GNUC__) && ! defined (__cplusplus)
  2010. f(int u){int i;long long x;x=u?~0:0;if(x)for(i=0;i<9;i++);x&=g();if(x)g();}
  2011. g(){}
  2012. #else
  2013. int dummy;
  2014. #endif
  2015. int main () { return 0; }
  2016. EOF
  2017.   echo "Test compile: long long reliability test 2" >&5
  2018.   gmp_compile="$cc $cflags $cppflags conftest.c >&5"
  2019.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  2020.   (eval $gmp_compile) 2>&5
  2021.   ac_status=$?
  2022.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2023.   test $ac_status = 0; }; then
  2024.     cc_works_part=yes
  2025.     if test "$cross_compiling" = no; then
  2026.       if { ac_try='./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest'
  2027.   { { eval echo ""$as_me":${as_lineno-$LINENO}: "$ac_try""; } >&5
  2028.   (eval $ac_try) 2>&5
  2029.   ac_status=$?
  2030.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2031.   test $ac_status = 0; }; }; then :;
  2032.       else
  2033.         cc_works_part=norun
  2034.       fi
  2035.     fi
  2036.   else
  2037.     cc_works_part=no
  2038.   fi
  2039.   if test "$cc_works_part" != yes; then
  2040.     echo "failed program was:" >&5
  2041.     cat conftest.c >&5
  2042.   fi
  2043.   rm -f conftest* a.out b.out a.exe a_out.exe
  2044.   case $cc_works_part in
  2045.     yes)
  2046.       ;;
  2047.     no)
  2048.       gmp_prog_cc_works="no, long long reliability test 2"
  2049.       ;;
  2050.     norun)
  2051.       gmp_prog_cc_works="no, long long reliability test 2, program does not run"
  2052.       ;;
  2053.   esac
  2054. fi
  2055. if test "$gmp_prog_cc_works" = yes; then
  2056.   # remove anything that might look like compiler output to our "||" expression
  2057.   rm -f conftest* a.out b.out a.exe a_out.exe
  2058.   cat >conftest.c <<EOF
  2059. /* The following is mis-compiled by HP ia-64 cc version
  2060.         cc: HP aC++/ANSI C B3910B A.05.55 [Dec 04 2003]
  2061.    under "cc +O3", both in +DD32 and +DD64 modes.  The mpn_lshift_com gets
  2062.    inlined and its return value somehow botched to be 0 instead of 1.  This
  2063.    arises in the real mpn_lshift_com in mul_fft.c.  A lower optimization
  2064.    level, like +O2 seems ok.  This code needs to be run to show the problem,
  2065.    but that's fine, the offending cc is a native-only compiler so we don't
  2066.    have to worry about cross compiling.  */
  2067. #if ! defined (__cplusplus)
  2068. unsigned long
  2069. lshift_com (rp, up, n, cnt)
  2070.   unsigned long *rp;
  2071.   unsigned long *up;
  2072.   long n;
  2073.   unsigned cnt;
  2074. {
  2075.   unsigned long retval, high_limb, low_limb;
  2076.   unsigned tnc;
  2077.   long i;
  2078.   tnc = 8 * sizeof (unsigned long) - cnt;
  2079.   low_limb = *up++;
  2080.   retval = low_limb >> tnc;
  2081.   high_limb = low_limb << cnt;
  2082.   for (i = n - 1; i != 0; i--)
  2083.     {
  2084.       low_limb = *up++;
  2085.       *rp++ = ~(high_limb | (low_limb >> tnc));
  2086.       high_limb = low_limb << cnt;
  2087.     }
  2088.   return retval;
  2089. }
  2090. int
  2091. main ()
  2092. {
  2093.   unsigned long cy, rp[2], up[2];
  2094.   up[0] = ~ 0L;
  2095.   up[1] = 0;
  2096.   cy = lshift_com (rp, up, 2L, 1);
  2097.   if (cy != 1L)
  2098.     return 1;
  2099.   return 0;
  2100. }
  2101. #else
  2102. int
  2103. main ()
  2104. {
  2105.   return 0;
  2106. }
  2107. #endif
  2108. EOF
  2109.   echo "Test compile: mpn_lshift_com optimization" >&5
  2110.   gmp_compile="$cc $cflags $cppflags conftest.c >&5"
  2111.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  2112.   (eval $gmp_compile) 2>&5
  2113.   ac_status=$?
  2114.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2115.   test $ac_status = 0; }; then
  2116.     cc_works_part=yes
  2117.     if test "$cross_compiling" = no; then
  2118.       if { ac_try='./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest'
  2119.   { { eval echo ""$as_me":${as_lineno-$LINENO}: "$ac_try""; } >&5
  2120.   (eval $ac_try) 2>&5
  2121.   ac_status=$?
  2122.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2123.   test $ac_status = 0; }; }; then :;
  2124.       else
  2125.         cc_works_part=norun
  2126.       fi
  2127.     fi
  2128.   else
  2129.     cc_works_part=no
  2130.   fi
  2131.   if test "$cc_works_part" != yes; then
  2132.     echo "failed program was:" >&5
  2133.     cat conftest.c >&5
  2134.   fi
  2135.   rm -f conftest* a.out b.out a.exe a_out.exe
  2136.   case $cc_works_part in
  2137.     yes)
  2138.       ;;
  2139.     no)
  2140.       gmp_prog_cc_works="no, mpn_lshift_com optimization"
  2141.       ;;
  2142.     norun)
  2143.       gmp_prog_cc_works="no, mpn_lshift_com optimization, program does not run"
  2144.       ;;
  2145.   esac
  2146. fi
  2147. if test "$gmp_prog_cc_works" = yes; then
  2148.   # remove anything that might look like compiler output to our "||" expression
  2149.   rm -f conftest* a.out b.out a.exe a_out.exe
  2150.   cat >conftest.c <<EOF
  2151. /* The following is mis-compiled by Intel ia-64 icc version 1.8 under
  2152.     "icc -O3",  After several calls, the function writes parial garbage to
  2153.     the result vector.  Perhaps relates to the chk.a.nc insn.  This code needs
  2154.     to be run to show the problem, but that's fine, the offending cc is a
  2155.     native-only compiler so we don't have to worry about cross compiling.  */
  2156. #if ! defined (__cplusplus)
  2157. #include <stdlib.h>
  2158. void
  2159. lshift_com (rp, up, n, cnt)
  2160.   unsigned long *rp;
  2161.   unsigned long *up;
  2162.   long n;
  2163.   unsigned cnt;
  2164. {
  2165.   unsigned long high_limb, low_limb;
  2166.   unsigned tnc;
  2167.   long i;
  2168.   up += n;
  2169.   rp += n;
  2170.   tnc = 8 * sizeof (unsigned long) - cnt;
  2171.   low_limb = *--up;
  2172.   high_limb = low_limb << cnt;
  2173.   for (i = n - 1; i != 0; i--)
  2174.     {
  2175.       low_limb = *--up;
  2176.       *--rp = ~(high_limb | (low_limb >> tnc));
  2177.       high_limb = low_limb << cnt;
  2178.     }
  2179.   *--rp = ~high_limb;
  2180. }
  2181. int
  2182. main ()
  2183. {
  2184.   unsigned long *r, *r2;
  2185.   unsigned long a[88 + 1];
  2186.   long i;
  2187.   for (i = 0; i < 88 + 1; i++)
  2188.     a[i] = ~0L;
  2189.   r = malloc (10000 * sizeof (unsigned long));
  2190.   r2 = r;
  2191.   for (i = 0; i < 528; i += 22)
  2192.     {
  2193.       lshift_com (r2, a,
  2194.   i / (8 * sizeof (unsigned long)) + 1,
  2195.   i % (8 * sizeof (unsigned long)));
  2196.       r2 += 88 + 1;
  2197.     }
  2198.   if (r[2048] != 0 || r[2049] != 0 || r[2050] != 0 || r[2051] != 0 ||
  2199.       r[2052] != 0 || r[2053] != 0 || r[2054] != 0)
  2200.     abort ();
  2201.   return 0;
  2202. }
  2203. #else
  2204. int
  2205. main ()
  2206. {
  2207.   return 0;
  2208. }
  2209. #endif
  2210. EOF
  2211.   echo "Test compile: mpn_lshift_com optimization 2" >&5
  2212.   gmp_compile="$cc $cflags $cppflags conftest.c >&5"
  2213.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  2214.   (eval $gmp_compile) 2>&5
  2215.   ac_status=$?
  2216.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2217.   test $ac_status = 0; }; then
  2218.     cc_works_part=yes
  2219.     if test "$cross_compiling" = no; then
  2220.       if { ac_try='./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest'
  2221.   { { eval echo ""$as_me":${as_lineno-$LINENO}: "$ac_try""; } >&5
  2222.   (eval $ac_try) 2>&5
  2223.   ac_status=$?
  2224.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2225.   test $ac_status = 0; }; }; then :;
  2226.       else
  2227.         cc_works_part=norun
  2228.       fi
  2229.     fi
  2230.   else
  2231.     cc_works_part=no
  2232.   fi
  2233.   if test "$cc_works_part" != yes; then
  2234.     echo "failed program was:" >&5
  2235.     cat conftest.c >&5
  2236.   fi
  2237.   rm -f conftest* a.out b.out a.exe a_out.exe
  2238.   case $cc_works_part in
  2239.     yes)
  2240.       ;;
  2241.     no)
  2242.       gmp_prog_cc_works="no, mpn_lshift_com optimization 2"
  2243.       ;;
  2244.     norun)
  2245.       gmp_prog_cc_works="no, mpn_lshift_com optimization 2, program does not run"
  2246.       ;;
  2247.   esac
  2248. fi
  2249. # A certain _GLOBAL_OFFSET_TABLE_ problem in past versions of gas, tickled
  2250. # by recent versions of gcc.
  2251. #
  2252. if test "$gmp_prog_cc_works" = yes; then
  2253.   case $host in
  2254.     i?86*-*-* | k[5-8]*-*-* | pentium*-*-* | athlon-*-* | viac3*-*-* | geode*-*-* | atom-*-*)
  2255.       # this problem only arises in PIC code, so don't need to test when
  2256.       # --disable-shared.  We don't necessarily have $enable_shared set to
  2257.       # yes at this point, it will still be unset for the default (which is
  2258.       # yes); hence the use of "!= no".
  2259.       if test "$enable_shared" != no; then
  2260.         echo "Testing gcc GOT with eax emitted" >&5
  2261. cat >conftest.c <<EOF
  2262. int foo;
  2263. int bar () { return foo; }
  2264. EOF
  2265. tmp_got_emitted=no
  2266. gmp_compile="$cc $cflags $cppflags -fPIC -S conftest.c >&5 2>&1"
  2267. if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  2268.   (eval $gmp_compile) 2>&5
  2269.   ac_status=$?
  2270.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2271.   test $ac_status = 0; }; then
  2272.   if grep "addl.*_GLOBAL_OFFSET_TABLE_.*eax" conftest.s >/dev/null; then
  2273.     tmp_got_emitted=yes
  2274.   fi
  2275. fi
  2276. rm -f conftest.*
  2277. echo "Result: $tmp_got_emitted" >&5
  2278. if test "$tmp_got_emitted" = yes; then
  2279.   echo "Testing gas GOT with eax good" >&5
  2280. cat >conftest.awk <<EOF
  2281. BEGIN {
  2282.   want[0]  = "001"
  2283.   want[1]  = "043"
  2284.   want[2]  = "105"
  2285.   want[3]  = "147"
  2286.   want[4]  = "211"
  2287.   want[5]  = "253"
  2288.   want[6]  = "315"
  2289.   want[7]  = "357"
  2290.   want[8]  = "005"
  2291.   want[9]  = "002"
  2292.   want[10] = "000"
  2293.   want[11] = "000"
  2294.   want[12] = "000"
  2295.   want[13] = "376"
  2296.   want[14] = "334"
  2297.   want[15] = "272"
  2298.   want[16] = "230"
  2299.   want[17] = "166"
  2300.   want[18] = "124"
  2301.   want[19] = "062"
  2302.   want[20] = "020"
  2303.   result = "yes"
  2304. }
  2305. {
  2306.   for (f = 2; f <= NF; f++)
  2307.     {
  2308.       for (i = 0; i < 20; i++)
  2309.         got[i] = got[i+1];
  2310.       got[20] = $f;
  2311.       found = 1
  2312.       for (i = 0; i < 21; i++)
  2313.         if (got[i] != want[i])
  2314.           {
  2315.             found = 0
  2316.             break
  2317.           }
  2318.       if (found)
  2319.         {
  2320.           result = "no"
  2321.           exit
  2322.         }
  2323.     }
  2324. }
  2325. END {
  2326.   print result
  2327. }
  2328. EOF
  2329. cat >conftest.s <<EOF
  2330. .text
  2331. .byte 1, 35, 69, 103, 137, 171, 205, 239
  2332. addl $_GLOBAL_OFFSET_TABLE_, %eax
  2333. .byte 254, 220, 186, 152, 118, 84, 50, 16
  2334. EOF
  2335. tmp_got_good=yes
  2336. gmp_compile="$cc $cflags $cppflags -fPIC -o conftest.o -c conftest.s >&5 2>&1"
  2337. if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  2338.   (eval $gmp_compile) 2>&5
  2339.   ac_status=$?
  2340.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2341.   test $ac_status = 0; }; then
  2342.   tmp_got_good=`od -b conftest.o | $AWK -f conftest.awk`
  2343. fi
  2344. rm -f conftest.*
  2345. echo "Result: $tmp_got_good" >&5
  2346. if test "$tmp_got_good" = no; then
  2347.   gmp_prog_cc_works="no, bad gas GOT with eax"
  2348. else
  2349.   :
  2350. fi
  2351. else
  2352.   :
  2353. fi
  2354.       fi
  2355.       ;;
  2356.   esac
  2357. fi
  2358. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $gmp_prog_cc_works" >&5
  2359. $as_echo "$gmp_prog_cc_works" >&6; }
  2360. case $gmp_prog_cc_works in
  2361.   yes)
  2362.     ;;
  2363.   *)
  2364.     continue
  2365.     ;;
  2366. esac
  2367.         # If we're supposed to be using a "long long" for a limb, check that
  2368.         # it works.
  2369.                                   eval limb_chosen="$limb$abi1"
  2370.         test -n "$limb_chosen" || eval limb_chosen="$limb$abi2"
  2371.         if test "$limb_chosen" = longlong; then
  2372.           { $as_echo "$as_me:${as_lineno-$LINENO}: checking compiler $cc $cflags $cppflags has long long" >&5
  2373. $as_echo_n "checking compiler $cc $cflags $cppflags has long long... " >&6; }
  2374. cat >conftest.c <<EOF
  2375. long long  foo;
  2376. long long  bar () { return foo; }
  2377. int main () { return 0; }
  2378. EOF
  2379. gmp_prog_cc_works=no
  2380. gmp_compile="$cc $cflags $cppflags -c conftest.c >&5"
  2381. if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  2382.   (eval $gmp_compile) 2>&5
  2383.   ac_status=$?
  2384.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2385.   test $ac_status = 0; }; then
  2386.   gmp_prog_cc_works=yes
  2387. else
  2388.   echo "failed program was:" >&5
  2389.   cat conftest.c >&5
  2390. fi
  2391. rm -f conftest* a.out b.out a.exe a_out.exe
  2392. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $gmp_prog_cc_works" >&5
  2393. $as_echo "$gmp_prog_cc_works" >&6; }
  2394. if test $gmp_prog_cc_works = yes; then
  2395.   :
  2396. else
  2397.   continue
  2398. fi
  2399.         fi
  2400.         # The tests to perform on this $cc, if any
  2401.                                eval testlist="$${ccbase}${abi1}_testlist"
  2402.         test -n "$testlist" || eval testlist="$${ccbase}${abi2}_testlist"
  2403.         test -n "$testlist" || eval testlist="$any${abi1}_testlist"
  2404.         test -n "$testlist" || eval testlist="$any${abi2}_testlist"
  2405.         testlist_pass=yes
  2406.         for tst in $testlist; do
  2407.           case $tst in
  2408.           hpc-hppa-2-0)   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether HP compiler $cc is good for 64-bits" >&5
  2409. $as_echo_n "checking whether HP compiler $cc is good for 64-bits... " >&6; }
  2410. # Bad compiler output:
  2411. #   ccom: HP92453-01 G.10.32.05 HP C Compiler
  2412. # Good compiler output:
  2413. #   ccom: HP92453-01 A.10.32.30 HP C Compiler
  2414. # Let A.10.32.30 or higher be ok.
  2415. echo >conftest.c
  2416. gmp_tmp_vs=`$cc  -V -c -o conftest.$OBJEXT conftest.c 2>&1 | grep "^ccom:"`
  2417. echo "Version string: $gmp_tmp_vs" >&5
  2418. rm conftest*
  2419. gmp_tmp_v1=`echo $gmp_tmp_vs | sed 's/.* ..([0-9]*).*/1/'`
  2420. gmp_tmp_v2=`echo $gmp_tmp_vs | sed 's/.* ...*.(.*)..* HP C.*/1/'`
  2421. gmp_tmp_v3=`echo $gmp_tmp_vs | sed 's/.* ...*..*.(.*) HP C.*/1/'`
  2422. echo "Version number: $gmp_tmp_v1.$gmp_tmp_v2.$gmp_tmp_v3" >&5
  2423. if test -z "$gmp_tmp_v1"; then
  2424.   gmp_hpc_64bit=not-applicable
  2425. else
  2426.   gmp_compare_ge=no
  2427. if test -n "$gmp_tmp_v1"; then
  2428.   if test "$gmp_tmp_v1" -gt 10; then
  2429.     gmp_compare_ge=yes
  2430.   else
  2431.     if test "$gmp_tmp_v1" -eq 10; then
  2432.       if test -n "$gmp_tmp_v2"; then
  2433.   if test "$gmp_tmp_v2" -gt 32; then
  2434.     gmp_compare_ge=yes
  2435.   else
  2436.     if test "$gmp_tmp_v2" -eq 32; then
  2437.       if test -n "$gmp_tmp_v3" && test "$gmp_tmp_v3" -ge 30; then
  2438.   gmp_compare_ge=yes
  2439. fi
  2440.     fi
  2441.   fi
  2442. fi
  2443.     fi
  2444.   fi
  2445. fi
  2446.   gmp_hpc_64bit=$gmp_compare_ge
  2447. fi
  2448. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $gmp_hpc_64bit" >&5
  2449. $as_echo "$gmp_hpc_64bit" >&6; }
  2450. if test $gmp_hpc_64bit = yes; then
  2451.   :
  2452. else
  2453.   testlist_pass=no
  2454. fi
  2455.  ;;
  2456.           gcc-arm-umodsi) { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ARM gcc unsigned division works" >&5
  2457. $as_echo_n "checking whether ARM gcc unsigned division works... " >&6; }
  2458. tmp_version=`$cc --version`
  2459. echo "$tmp_version" >&5
  2460. case $tmp_version in
  2461.   2.95 | 2.95.[123])
  2462.     testlist_pass=no
  2463.     gmp_gcc_arm_umodsi_result="no, gcc 2.95.[0123]" ;;
  2464.   *)
  2465.     :
  2466.     gmp_gcc_arm_umodsi_result=yes ;;
  2467. esac
  2468. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $gmp_gcc_arm_umodsi_result" >&5
  2469. $as_echo "$gmp_gcc_arm_umodsi_result" >&6; }
  2470.  ;;
  2471.           gcc-mips-o32)   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether gcc supports o32" >&5
  2472. $as_echo_n "checking whether gcc supports o32... " >&6; }
  2473. echo 'int x;' >conftest.c
  2474. echo "$cc -mabi=32 -c conftest.c" >&5
  2475. if $cc -mabi=32 -c conftest.c >conftest.out 2>&1; then
  2476.   result=yes
  2477. else
  2478.   cat conftest.out >&5
  2479.   if grep "cc1: Invalid option `abi=32'" conftest.out >/dev/null; then
  2480.     result=yes
  2481.   else
  2482.     result=no
  2483.   fi
  2484. fi
  2485. rm -f conftest.*
  2486. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $result" >&5
  2487. $as_echo "$result" >&6; }
  2488. if test $result = yes; then
  2489.   :
  2490. else
  2491.   testlist_pass=no
  2492. fi
  2493.  ;;
  2494.           hppa-level-2.0) { $as_echo "$as_me:${as_lineno-$LINENO}: checking $cc $cflags assembler knows hppa 2.0" >&5
  2495. $as_echo_n "checking $cc $cflags assembler knows hppa 2.0... " >&6; }
  2496. result=no
  2497. cat >conftest.s <<EOF
  2498. .level 2.0
  2499. EOF
  2500. gmp_compile="$cc $cflags -c conftest.s >&5 2>&1"
  2501. if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  2502.   (eval $gmp_compile) 2>&5
  2503.   ac_status=$?
  2504.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2505.   test $ac_status = 0; }; then
  2506.   result=yes
  2507. else
  2508.   echo "failed program was" >&5
  2509.   cat conftest.s >&5
  2510. fi
  2511. rm -f conftest*
  2512. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $result" >&5
  2513. $as_echo "$result" >&6; }
  2514. if test "$result" = yes; then
  2515.   :
  2516. else
  2517.   testlist_pass=no
  2518. fi
  2519.  ;;
  2520.           sizeof*)       echo "configure: testlist $tst" >&5
  2521. gmp_sizeof_type=`echo "$tst" | sed 's/sizeof-([a-z]*).*/1/'`
  2522. gmp_sizeof_want=`echo "$tst" | sed 's/sizeof-[a-z]*-([0-9]*).*/1/'`
  2523. { $as_echo "$as_me:${as_lineno-$LINENO}: checking compiler $cc $cflags has sizeof($gmp_sizeof_type)==$gmp_sizeof_want" >&5
  2524. $as_echo_n "checking compiler $cc $cflags has sizeof($gmp_sizeof_type)==$gmp_sizeof_want... " >&6; }
  2525. cat >conftest.c <<EOF
  2526. int
  2527. main ()
  2528. {
  2529.   static int test_array [1 - 2 * (long) (sizeof ($gmp_sizeof_type) != $gmp_sizeof_want)];
  2530.   test_array[0] = 0;
  2531.   return 0;
  2532. }
  2533. EOF
  2534. gmp_c_testlist_sizeof=no
  2535. gmp_compile="$cc $cflags -c conftest.c >&5"
  2536. if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  2537.   (eval $gmp_compile) 2>&5
  2538.   ac_status=$?
  2539.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2540.   test $ac_status = 0; }; then
  2541.   gmp_c_testlist_sizeof=yes
  2542. fi
  2543. rm -f conftest*
  2544. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $gmp_c_testlist_sizeof" >&5
  2545. $as_echo "$gmp_c_testlist_sizeof" >&6; }
  2546. if test $gmp_c_testlist_sizeof = yes; then
  2547.   :
  2548. else
  2549.   testlist_pass=no
  2550. fi
  2551.  ;;
  2552.           esac
  2553.           if test $testlist_pass = no; then break; fi
  2554.         done
  2555.         if test $testlist_pass = yes; then
  2556.           found_compiler=yes
  2557.           break
  2558.         fi
  2559.       done
  2560.       if test $found_compiler = yes; then break; fi
  2561.     done
  2562.     if test $found_compiler = yes; then break; fi
  2563.   done
  2564.   if test $found_compiler = yes; then break; fi
  2565. done
  2566. # If we recognised the CPU, as indicated by $path being set, then insist
  2567. # that we have a working compiler, either from our $cclist choices or from
  2568. # $CC.  We can't let AC_PROG_CC look around for a compiler because it might
  2569. # find one that we've rejected (for not supporting the modes our asm code
  2570. # demands, etc).
  2571. #
  2572. # If we didn't recognise the CPU (and this includes host_cpu=none), then
  2573. # fall through and let AC_PROG_CC look around for a compiler too.  This is
  2574. # mostly in the interests of following a standard autoconf setup, after all
  2575. # we've already tested cc and gcc adequately (hopefully).  As of autoconf
  2576. # 2.50 the only thing AC_PROG_CC really adds is a check for "cl" (Microsoft
  2577. # C on MS-DOS systems).
  2578. #
  2579. if test $found_compiler = no && test -n "$path"; then
  2580.   as_fn_error "could not find a working compiler, see config.log for details" "$LINENO" 5
  2581. fi
  2582. case $host in
  2583.   i?86*-*-* | k[5-8]*-*-* | pentium*-*-* | athlon-*-* | viac3*-*-* | geode*-*-* | atom-*-* | athlon64-*-* | pentium4-*-* | atom-*-* | core2-*-* | corei-*-* | x86_64-*-* | nano-*-*)
  2584.     # If the user asked for a fat build, override the path and flags set above
  2585.     if test $enable_fat = yes; then
  2586.       gcc_cflags_cpu=""
  2587.       gcc_cflags_arch=""
  2588.       if test "$abi" = 32; then
  2589. extra_functions="$extra_functions fat fat_entry"
  2590. path="x86/fat x86"
  2591. fat_path="x86 x86/fat x86/i486
  2592.   x86/k6 x86/k6/mmx x86/k6/k62mmx
  2593.   x86/k7 x86/k7/mmx
  2594.   x86/pentium x86/pentium/mmx
  2595.   x86/p6 x86/p6/mmx x86/p6/p3mmx x86/p6/sse2
  2596.   x86/pentium4 x86/pentium4/mmx x86/pentium4/sse2"
  2597.       fi
  2598.       if test "$abi" = 64; then
  2599. gcc_64_cflags=""
  2600. extra_functions_64="$extra_functions_64 fat fat_entry"
  2601. path_64="x86_64/fat x86_64"
  2602. fat_path="x86_64 x86_64/fat x86_64/pentium4 x86_64/core2 x86_64/corei x86_64/atom x86_64/nano"
  2603.       fi
  2604.       fat_functions="add_n addmul_1 copyd copyi
  2605.      dive_1 diveby3 divrem_1 gcd_1 lshift
  2606.      mod_1 mod_34lsub1 mode1o mul_1 mul_basecase
  2607.      pre_divrem_1 pre_mod_1 rshift
  2608.      sqr_basecase sub_n submul_1"
  2609.       fat_thresholds="MUL_TOOM22_THRESHOLD MUL_TOOM33_THRESHOLD
  2610.       SQR_TOOM2_THRESHOLD SQR_TOOM3_THRESHOLD"
  2611.     fi
  2612.     ;;
  2613. esac
  2614. if test $found_compiler = yes; then
  2615.   # If we're creating CFLAGS, then look for optional additions.  If the user
  2616.   # set CFLAGS then leave it alone.
  2617.   #
  2618.   if test "$test_CFLAGS" != set; then
  2619.                           eval optlist="$${ccbase}${abi1}_cflags_optlist"
  2620.     test -n "$optlist" || eval optlist="$${ccbase}${abi2}_cflags_optlist"
  2621.     for opt in $optlist; do
  2622.                              eval optflags="$${ccbase}${abi1}_cflags_${opt}"
  2623.       test -n "$optflags" || eval optflags="$${ccbase}${abi2}_cflags_${opt}"
  2624.       test -n "$optflags" || eval optflags="$${ccbase}_cflags_${opt}"
  2625.       for flag in $optflags; do
  2626. # ~ represents a space in an option spec
  2627.         flag=`echo "$flag" | tr '~' ' '`
  2628.         case $flag in
  2629.           -march=pentium4 | -march=k8)
  2630.             # For -march settings which enable SSE2 we exclude certain bad
  2631.             # gcc versions and we need an OS knowing how to save xmm regs.
  2632.             #
  2633.             # This is only for ABI=32, any 64-bit gcc is good and any OS
  2634.             # knowing x86_64 will know xmm.
  2635.             #
  2636.             # -march=k8 was only introduced in gcc 3.3, so we shouldn't need
  2637.             # the GMP_GCC_PENTIUM4_SSE2 check (for gcc 3.2 and prior).  But
  2638.             # it doesn't hurt to run it anyway, sharing code with the
  2639.             # pentium4 case.
  2640.             #
  2641.             if test "$abi" = 32; then
  2642.               { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether gcc is good for sse2" >&5
  2643. $as_echo_n "checking whether gcc is good for sse2... " >&6; }
  2644. case `$cc $cflags $cppflags -dumpversion` in
  2645.   3.[012] | 3.[012].*) result=no ;;
  2646.   *)                     result=yes ;;
  2647. esac
  2648. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $result" >&5
  2649. $as_echo "$result" >&6; }
  2650. if test "$result" = yes; then
  2651.   :
  2652. else
  2653.   continue
  2654. fi
  2655.               { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the operating system supports XMM registers" >&5
  2656. $as_echo_n "checking whether the operating system supports XMM registers... " >&6; }
  2657. if test "${gmp_cv_os_x86_xmm+set}" = set; then :
  2658.   $as_echo_n "(cached) " >&6
  2659. else
  2660.   if test "$build" = "$host"; then
  2661.   # remove anything that might look like compiler output to our "||" expression
  2662.   rm -f conftest* a.out b.out a.exe a_out.exe
  2663.   cat >conftest.s <<EOF
  2664. .text
  2665. main:
  2666. _main:
  2667. .globl main
  2668. .globl _main
  2669. .byte 0x0f, 0x57, 0xc0
  2670. xorl %eax, %eax
  2671. ret
  2672. EOF
  2673.   gmp_compile="$cc $cflags $cppflags conftest.s -o conftest >&5"
  2674.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  2675.   (eval $gmp_compile) 2>&5
  2676.   ac_status=$?
  2677.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2678.   test $ac_status = 0; }; then
  2679.     if { ac_try='./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest'
  2680.   { { eval echo ""$as_me":${as_lineno-$LINENO}: "$ac_try""; } >&5
  2681.   (eval $ac_try) 2>&5
  2682.   ac_status=$?
  2683.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2684.   test $ac_status = 0; }; }; then
  2685.       gmp_cv_os_x86_xmm=yes
  2686.     else
  2687.       gmp_cv_os_x86_xmm=no
  2688.     fi
  2689.   else
  2690.     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Oops, cannot compile test program" >&5
  2691. $as_echo "$as_me: WARNING: Oops, cannot compile test program" >&2;}
  2692.   fi
  2693.   rm -f conftest*
  2694. fi
  2695. if test -z "$gmp_cv_os_x86_xmm"; then
  2696.   case $host_os in
  2697.     freebsd[123] | freebsd[123].*)
  2698.       gmp_cv_os_x86_xmm=no ;;
  2699.     freebsd*)
  2700.       gmp_cv_os_x86_xmm=yes ;;
  2701.     *)
  2702.       gmp_cv_os_x86_xmm=probably ;;
  2703.   esac
  2704. fi
  2705. fi
  2706. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $gmp_cv_os_x86_xmm" >&5
  2707. $as_echo "$gmp_cv_os_x86_xmm" >&6; }
  2708. if test "$gmp_cv_os_x86_xmm" = probably; then
  2709.   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Not certain of OS support for xmm when cross compiling." >&5
  2710. $as_echo "$as_me: WARNING: Not certain of OS support for xmm when cross compiling." >&2;}
  2711.   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Will assume it's ok, expect a SIGILL if this is wrong." >&5
  2712. $as_echo "$as_me: WARNING: Will assume it's ok, expect a SIGILL if this is wrong." >&2;}
  2713. fi
  2714. case $gmp_cv_os_x86_xmm in
  2715. no)
  2716.   continue
  2717.   ;;
  2718. *)
  2719.   ;;
  2720. esac
  2721.             fi
  2722.             ;;
  2723.           -no-cpp-precomp)
  2724.             # special check, avoiding a warning
  2725.             if test "$ccbase" = gcc; then
  2726.   { $as_echo "$as_me:${as_lineno-$LINENO}: checking compiler $cc $cflags -no-cpp-precomp" >&5
  2727. $as_echo_n "checking compiler $cc $cflags -no-cpp-precomp... " >&6; }
  2728.   result=no
  2729.   cat >conftest.c <<EOF
  2730. int main () { return 0; }
  2731. EOF
  2732.   gmp_compile="$cc $cflags -no-cpp-precomp conftest.c >conftest.out 2>&1"
  2733.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  2734.   (eval $gmp_compile) 2>&5
  2735.   ac_status=$?
  2736.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2737.   test $ac_status = 0; }; then
  2738.     if grep "unrecognized option.*-no-cpp-precomp" conftest.out >/dev/null; then : ;
  2739.     else
  2740.       result=yes
  2741.     fi
  2742.   fi
  2743.   cat conftest.out >&5
  2744.   rm -f conftest* a.out b.out a.exe a_out.exe
  2745.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $result" >&5
  2746. $as_echo "$result" >&6; }
  2747.   if test "$result" = yes; then
  2748.       cflags="$cflags $flag"
  2749.                                    break
  2750.   else
  2751.       continue
  2752.   fi
  2753. fi
  2754.             ;;
  2755.           -Wa,-m*)
  2756.             case $host in
  2757.               alpha*-*-*)
  2758.                 { $as_echo "$as_me:${as_lineno-$LINENO}: checking assembler $cc $cflags $flag" >&5
  2759. $as_echo_n "checking assembler $cc $cflags $flag... " >&6; }
  2760. result=no
  2761. cat >conftest.c <<EOF
  2762. int main () {}
  2763. EOF
  2764. gmp_compile="$cc $cflags $flag -c conftest.c >conftest.out 2>&1"
  2765. if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  2766.   (eval $gmp_compile) 2>&5
  2767.   ac_status=$?
  2768.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2769.   test $ac_status = 0; }; then
  2770.   if grep "Unknown CPU identifier" conftest.out >/dev/null; then : ;
  2771.   else
  2772.     result=yes
  2773.   fi
  2774. fi
  2775. cat conftest.out >&5
  2776. rm -f conftest*
  2777. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $result" >&5
  2778. $as_echo "$result" >&6; }
  2779. if test "$result" = yes; then
  2780.   :
  2781. else
  2782.   continue
  2783. fi
  2784.               ;;
  2785.             esac
  2786.             ;;
  2787.           -Wa,-oldas)
  2788.             { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $cc $cflags $cppflags -Wa,-oldas" >&5
  2789. $as_echo_n "checking for $cc $cflags $cppflags -Wa,-oldas... " >&6; }
  2790. result=no
  2791. cat >conftest.c <<EOF
  2792. EOF
  2793. echo "with empty conftest.c" >&5
  2794. gmp_compile="$cc $cflags $cppflags -c conftest.c >&5 2>&1"
  2795. if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  2796.   (eval $gmp_compile) 2>&5
  2797.   ac_status=$?
  2798.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2799.   test $ac_status = 0; }; then : ;
  2800. else
  2801.   # empty fails
  2802.   gmp_compile="$cc $cflags $cppflags -Wa,-oldas -c conftest.c >&5 2>&1"
  2803.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  2804.   (eval $gmp_compile) 2>&5
  2805.   ac_status=$?
  2806.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2807.   test $ac_status = 0; }; then
  2808.     # but with -Wa,-oldas it works
  2809.     result=yes
  2810.   fi
  2811. fi
  2812. rm -f conftest*
  2813. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $result" >&5
  2814. $as_echo "$result" >&6; }
  2815. if test "$result" = yes; then
  2816.   cflags="$cflags $flag"
  2817.                              break
  2818. else
  2819.   continue
  2820. fi
  2821.             ;;
  2822.         esac
  2823.         { $as_echo "$as_me:${as_lineno-$LINENO}: checking compiler $cc $cflags $cppflags $flag" >&5
  2824. $as_echo_n "checking compiler $cc $cflags $cppflags $flag... " >&6; }
  2825. gmp_prog_cc_works=yes
  2826. # first see a simple "main()" works, then go on to other checks
  2827. if test "$gmp_prog_cc_works" = yes; then
  2828.   # remove anything that might look like compiler output to our "||" expression
  2829.   rm -f conftest* a.out b.out a.exe a_out.exe
  2830.   cat >conftest.c <<EOF
  2831. int main () { return 0; }
  2832. EOF
  2833.   echo "Test compile: " >&5
  2834.   gmp_compile="$cc $cflags $cppflags $flag conftest.c >&5"
  2835.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  2836.   (eval $gmp_compile) 2>&5
  2837.   ac_status=$?
  2838.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2839.   test $ac_status = 0; }; then
  2840.     cc_works_part=yes
  2841.     if test "$cross_compiling" = no; then
  2842.       if { ac_try='./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest'
  2843.   { { eval echo ""$as_me":${as_lineno-$LINENO}: "$ac_try""; } >&5
  2844.   (eval $ac_try) 2>&5
  2845.   ac_status=$?
  2846.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2847.   test $ac_status = 0; }; }; then :;
  2848.       else
  2849.         cc_works_part=norun
  2850.       fi
  2851.     fi
  2852.   else
  2853.     cc_works_part=no
  2854.   fi
  2855.   if test "$cc_works_part" != yes; then
  2856.     echo "failed program was:" >&5
  2857.     cat conftest.c >&5
  2858.   fi
  2859.   rm -f conftest* a.out b.out a.exe a_out.exe
  2860.   case $cc_works_part in
  2861.     yes)
  2862.       ;;
  2863.     no)
  2864.       gmp_prog_cc_works="no"
  2865.       ;;
  2866.     norun)
  2867.       gmp_prog_cc_works="no, program does not run"
  2868.       ;;
  2869.   esac
  2870. fi
  2871. if test "$gmp_prog_cc_works" = yes; then
  2872.   # remove anything that might look like compiler output to our "||" expression
  2873.   rm -f conftest* a.out b.out a.exe a_out.exe
  2874.   cat >conftest.c <<EOF
  2875. /* The following provokes an internal error from gcc 2.95.2 -mpowerpc64
  2876.    (without -maix64), hence detecting an unusable compiler */
  2877. void *g() { return (void *) 0; }
  2878. void *f() { return g(); }
  2879. int main () { return 0; }
  2880. EOF
  2881.   echo "Test compile: function pointer return" >&5
  2882.   gmp_compile="$cc $cflags $cppflags $flag conftest.c >&5"
  2883.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  2884.   (eval $gmp_compile) 2>&5
  2885.   ac_status=$?
  2886.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2887.   test $ac_status = 0; }; then
  2888.     cc_works_part=yes
  2889.     if test "$cross_compiling" = no; then
  2890.       if { ac_try='./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest'
  2891.   { { eval echo ""$as_me":${as_lineno-$LINENO}: "$ac_try""; } >&5
  2892.   (eval $ac_try) 2>&5
  2893.   ac_status=$?
  2894.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2895.   test $ac_status = 0; }; }; then :;
  2896.       else
  2897.         cc_works_part=norun
  2898.       fi
  2899.     fi
  2900.   else
  2901.     cc_works_part=no
  2902.   fi
  2903.   if test "$cc_works_part" != yes; then
  2904.     echo "failed program was:" >&5
  2905.     cat conftest.c >&5
  2906.   fi
  2907.   rm -f conftest* a.out b.out a.exe a_out.exe
  2908.   case $cc_works_part in
  2909.     yes)
  2910.       ;;
  2911.     no)
  2912.       gmp_prog_cc_works="no, function pointer return"
  2913.       ;;
  2914.     norun)
  2915.       gmp_prog_cc_works="no, function pointer return, program does not run"
  2916.       ;;
  2917.   esac
  2918. fi
  2919. if test "$gmp_prog_cc_works" = yes; then
  2920.   # remove anything that might look like compiler output to our "||" expression
  2921.   rm -f conftest* a.out b.out a.exe a_out.exe
  2922.   cat >conftest.c <<EOF
  2923. /* The following provokes an invalid instruction syntax from i386 gcc
  2924.    -march=pentiumpro on Solaris 2.8.  The native sun assembler
  2925.    requires a non-standard syntax for cmov which gcc (as of 2.95.2 at
  2926.    least) doesn't know.  */
  2927. int n;
  2928. int cmov () { return (n >= 0 ? n : 0); }
  2929. int main () { return 0; }
  2930. EOF
  2931.   echo "Test compile: cmov instruction" >&5
  2932.   gmp_compile="$cc $cflags $cppflags $flag conftest.c >&5"
  2933.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  2934.   (eval $gmp_compile) 2>&5
  2935.   ac_status=$?
  2936.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2937.   test $ac_status = 0; }; then
  2938.     cc_works_part=yes
  2939.     if test "$cross_compiling" = no; then
  2940.       if { ac_try='./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest'
  2941.   { { eval echo ""$as_me":${as_lineno-$LINENO}: "$ac_try""; } >&5
  2942.   (eval $ac_try) 2>&5
  2943.   ac_status=$?
  2944.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2945.   test $ac_status = 0; }; }; then :;
  2946.       else
  2947.         cc_works_part=norun
  2948.       fi
  2949.     fi
  2950.   else
  2951.     cc_works_part=no
  2952.   fi
  2953.   if test "$cc_works_part" != yes; then
  2954.     echo "failed program was:" >&5
  2955.     cat conftest.c >&5
  2956.   fi
  2957.   rm -f conftest* a.out b.out a.exe a_out.exe
  2958.   case $cc_works_part in
  2959.     yes)
  2960.       ;;
  2961.     no)
  2962.       gmp_prog_cc_works="no, cmov instruction"
  2963.       ;;
  2964.     norun)
  2965.       gmp_prog_cc_works="no, cmov instruction, program does not run"
  2966.       ;;
  2967.   esac
  2968. fi
  2969. if test "$gmp_prog_cc_works" = yes; then
  2970.   # remove anything that might look like compiler output to our "||" expression
  2971.   rm -f conftest* a.out b.out a.exe a_out.exe
  2972.   cat >conftest.c <<EOF
  2973. /* The following provokes a linker invocation problem with gcc 3.0.3
  2974.    on AIX 4.3 under "-maix64 -mpowerpc64 -mcpu=630".  The -mcpu=630
  2975.    option causes gcc to incorrectly select the 32-bit libgcc.a, not
  2976.    the 64-bit one, and consequently it misses out on the __fixunsdfdi
  2977.    helper (double -> uint64 conversion).  */
  2978. double d;
  2979. unsigned long gcc303 () { return (unsigned long) d; }
  2980. int main () { return 0; }
  2981. EOF
  2982.   echo "Test compile: double -> ulong conversion" >&5
  2983.   gmp_compile="$cc $cflags $cppflags $flag conftest.c >&5"
  2984.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  2985.   (eval $gmp_compile) 2>&5
  2986.   ac_status=$?
  2987.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2988.   test $ac_status = 0; }; then
  2989.     cc_works_part=yes
  2990.     if test "$cross_compiling" = no; then
  2991.       if { ac_try='./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest'
  2992.   { { eval echo ""$as_me":${as_lineno-$LINENO}: "$ac_try""; } >&5
  2993.   (eval $ac_try) 2>&5
  2994.   ac_status=$?
  2995.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2996.   test $ac_status = 0; }; }; then :;
  2997.       else
  2998.         cc_works_part=norun
  2999.       fi
  3000.     fi
  3001.   else
  3002.     cc_works_part=no
  3003.   fi
  3004.   if test "$cc_works_part" != yes; then
  3005.     echo "failed program was:" >&5
  3006.     cat conftest.c >&5
  3007.   fi
  3008.   rm -f conftest* a.out b.out a.exe a_out.exe
  3009.   case $cc_works_part in
  3010.     yes)
  3011.       ;;
  3012.     no)
  3013.       gmp_prog_cc_works="no, double -> ulong conversion"
  3014.       ;;
  3015.     norun)
  3016.       gmp_prog_cc_works="no, double -> ulong conversion, program does not run"
  3017.       ;;
  3018.   esac
  3019. fi
  3020. if test "$gmp_prog_cc_works" = yes; then
  3021.   # remove anything that might look like compiler output to our "||" expression
  3022.   rm -f conftest* a.out b.out a.exe a_out.exe
  3023.   cat >conftest.c <<EOF
  3024. /* The following provokes an error from hppa gcc 2.95 under -mpa-risc-2-0 if
  3025.    the assembler doesn't know hppa 2.0 instructions.  fneg is a 2.0
  3026.    instruction, and a negation like this comes out using it.  */
  3027. double fneg_data;
  3028. unsigned long fneg () { return -fneg_data; }
  3029. int main () { return 0; }
  3030. EOF
  3031.   echo "Test compile: double negation" >&5
  3032.   gmp_compile="$cc $cflags $cppflags $flag conftest.c >&5"
  3033.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  3034.   (eval $gmp_compile) 2>&5
  3035.   ac_status=$?
  3036.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  3037.   test $ac_status = 0; }; then
  3038.     cc_works_part=yes
  3039.     if test "$cross_compiling" = no; then
  3040.       if { ac_try='./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest'
  3041.   { { eval echo ""$as_me":${as_lineno-$LINENO}: "$ac_try""; } >&5
  3042.   (eval $ac_try) 2>&5
  3043.   ac_status=$?
  3044.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  3045.   test $ac_status = 0; }; }; then :;
  3046.       else
  3047.         cc_works_part=norun
  3048.       fi
  3049.     fi
  3050.   else
  3051.     cc_works_part=no
  3052.   fi
  3053.   if test "$cc_works_part" != yes; then
  3054.     echo "failed program was:" >&5
  3055.     cat conftest.c >&5
  3056.   fi
  3057.   rm -f conftest* a.out b.out a.exe a_out.exe
  3058.   case $cc_works_part in
  3059.     yes)
  3060.       ;;
  3061.     no)
  3062.       gmp_prog_cc_works="no, double negation"
  3063.       ;;
  3064.     norun)
  3065.       gmp_prog_cc_works="no, double negation, program does not run"
  3066.       ;;
  3067.   esac
  3068. fi
  3069. if test "$gmp_prog_cc_works" = yes; then
  3070.   # remove anything that might look like compiler output to our "||" expression
  3071.   rm -f conftest* a.out b.out a.exe a_out.exe
  3072.   cat >conftest.c <<EOF
  3073. /* The following makes gcc 3.3 -march=pentium4 generate an SSE2 xmm insn
  3074.    (cvtsd2ss) which will provoke an error if the assembler doesn't recognise
  3075.    those instructions.  Not sure how much of the gmp code will come out
  3076.    wanting sse2, but it's easiest to reject an option we know is bad.  */
  3077. double ftod_data;
  3078. float ftod () { return (float) ftod_data; }
  3079. int main () { return 0; }
  3080. EOF
  3081.   echo "Test compile: double -> float conversion" >&5
  3082.   gmp_compile="$cc $cflags $cppflags $flag conftest.c >&5"
  3083.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  3084.   (eval $gmp_compile) 2>&5
  3085.   ac_status=$?
  3086.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  3087.   test $ac_status = 0; }; then
  3088.     cc_works_part=yes
  3089.     if test "$cross_compiling" = no; then
  3090.       if { ac_try='./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest'
  3091.   { { eval echo ""$as_me":${as_lineno-$LINENO}: "$ac_try""; } >&5
  3092.   (eval $ac_try) 2>&5
  3093.   ac_status=$?
  3094.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  3095.   test $ac_status = 0; }; }; then :;
  3096.       else
  3097.         cc_works_part=norun
  3098.       fi
  3099.     fi
  3100.   else
  3101.     cc_works_part=no
  3102.   fi
  3103.   if test "$cc_works_part" != yes; then
  3104.     echo "failed program was:" >&5
  3105.     cat conftest.c >&5
  3106.   fi
  3107.   rm -f conftest* a.out b.out a.exe a_out.exe
  3108.   case $cc_works_part in
  3109.     yes)
  3110.       ;;
  3111.     no)
  3112.       gmp_prog_cc_works="no, double -> float conversion"
  3113.       ;;
  3114.     norun)
  3115.       gmp_prog_cc_works="no, double -> float conversion, program does not run"
  3116.       ;;
  3117.   esac
  3118. fi
  3119. if test "$gmp_prog_cc_works" = yes; then
  3120.   # remove anything that might look like compiler output to our "||" expression
  3121.   rm -f conftest* a.out b.out a.exe a_out.exe
  3122.   cat >conftest.c <<EOF
  3123. /* The following provokes an internal compiler error from gcc version
  3124.    "2.9-gnupro-99r1" under "-O2 -mcpu=ev6", apparently relating to char
  3125.    values being spilled into floating point registers.  The problem doesn't
  3126.    show up all the time, but has occurred enough in GMP for us to reject
  3127.    this compiler+flags.  */
  3128. #include <string.h>  /* for memcpy */
  3129. struct try_t
  3130. {
  3131.  char dst[2];
  3132.  char size;
  3133.  long d0, d1, d2, d3, d4, d5, d6;
  3134.  char overlap;
  3135. };
  3136. struct try_t param[6];
  3137. int
  3138. param_init ()
  3139. {
  3140.  struct try_t *p;
  3141.  memcpy (p, &param[ 2 ], sizeof (*p));
  3142.  memcpy (p, &param[ 2 ], sizeof (*p));
  3143.  p->size = 2;
  3144.  memcpy (p, &param[ 1 ], sizeof (*p));
  3145.  p->dst[0] = 1;
  3146.  p->overlap = 2;
  3147.  memcpy (p, &param[ 3 ], sizeof (*p));
  3148.  p->dst[0] = 1;
  3149.  p->overlap = 8;
  3150.  memcpy (p, &param[ 4 ], sizeof (*p));
  3151.  memcpy (p, &param[ 4 ], sizeof (*p));
  3152.  p->overlap = 8;
  3153.  memcpy (p, &param[ 5 ], sizeof (*p));
  3154.  memcpy (p, &param[ 5 ], sizeof (*p));
  3155.  memcpy (p, &param[ 5 ], sizeof (*p));
  3156.  return 0;
  3157. }
  3158. int main () { return 0; }
  3159. EOF
  3160.   echo "Test compile: gnupro alpha ev6 char spilling" >&5
  3161.   gmp_compile="$cc $cflags $cppflags $flag conftest.c >&5"
  3162.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  3163.   (eval $gmp_compile) 2>&5
  3164.   ac_status=$?
  3165.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  3166.   test $ac_status = 0; }; then
  3167.     cc_works_part=yes
  3168.     if test "$cross_compiling" = no; then
  3169.       if { ac_try='./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest'
  3170.   { { eval echo ""$as_me":${as_lineno-$LINENO}: "$ac_try""; } >&5
  3171.   (eval $ac_try) 2>&5
  3172.   ac_status=$?
  3173.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  3174.   test $ac_status = 0; }; }; then :;
  3175.       else
  3176.         cc_works_part=norun
  3177.       fi
  3178.     fi
  3179.   else
  3180.     cc_works_part=no
  3181.   fi
  3182.   if test "$cc_works_part" != yes; then
  3183.     echo "failed program was:" >&5
  3184.     cat conftest.c >&5
  3185.   fi
  3186.   rm -f conftest* a.out b.out a.exe a_out.exe
  3187.   case $cc_works_part in
  3188.     yes)
  3189.       ;;
  3190.     no)
  3191.       gmp_prog_cc_works="no, gnupro alpha ev6 char spilling"
  3192.       ;;
  3193.     norun)
  3194.       gmp_prog_cc_works="no, gnupro alpha ev6 char spilling, program does not run"
  3195.       ;;
  3196.   esac
  3197. fi
  3198. # __builtin_alloca is not available everywhere, check it exists before
  3199. # seeing that it works
  3200. if test "$gmp_prog_cc_works" = yes; then
  3201.   # remove anything that might look like compiler output to our "||" expression
  3202.   rm -f conftest* a.out b.out a.exe a_out.exe
  3203.   cat >conftest.c <<EOF
  3204. int k; int foo () { __builtin_alloca (k); }
  3205. EOF
  3206.   echo "Test compile: __builtin_alloca availability" >&5
  3207.   gmp_compile="$cc $cflags $cppflags $flag conftest.c >&5"
  3208.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  3209.   (eval $gmp_compile) 2>&5
  3210.   ac_status=$?
  3211.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  3212.   test $ac_status = 0; }; then
  3213.     cc_works_part=yes
  3214.     if test "$cross_compiling" = no; then
  3215.       if { ac_try='./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest'
  3216.   { { eval echo ""$as_me":${as_lineno-$LINENO}: "$ac_try""; } >&5
  3217.   (eval $ac_try) 2>&5
  3218.   ac_status=$?
  3219.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  3220.   test $ac_status = 0; }; }; then :;
  3221.       else
  3222.         cc_works_part=norun
  3223.       fi
  3224.     fi
  3225.   else
  3226.     cc_works_part=no
  3227.   fi
  3228.   if test "$cc_works_part" != yes; then
  3229.     echo "failed program was:" >&5
  3230.     cat conftest.c >&5
  3231.   fi
  3232.   rm -f conftest* a.out b.out a.exe a_out.exe
  3233.   case $cc_works_part in
  3234.     yes)
  3235.       if test "$gmp_prog_cc_works" = yes; then
  3236.   # remove anything that might look like compiler output to our "||" expression
  3237.   rm -f conftest* a.out b.out a.exe a_out.exe
  3238.   cat >conftest.c <<EOF
  3239. /* The following provokes an internal compiler error from Itanium HP-UX cc
  3240.     under +O2 or higher.  We use this sort of code in mpn/generic/mul_fft.c. */
  3241. int k;
  3242. int foo ()
  3243. {
  3244.   int i, **a;
  3245.   a = __builtin_alloca (k);
  3246.   for (i = 0; i <= k; i++)
  3247.     a[i] = __builtin_alloca (1 << i);
  3248. }
  3249. int main () { return 0; }
  3250. EOF
  3251.   echo "Test compile: alloca array" >&5
  3252.   gmp_compile="$cc $cflags $cppflags $flag conftest.c >&5"
  3253.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  3254.   (eval $gmp_compile) 2>&5
  3255.   ac_status=$?
  3256.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  3257.   test $ac_status = 0; }; then
  3258.     cc_works_part=yes
  3259.     if test "$cross_compiling" = no; then
  3260.       if { ac_try='./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest'
  3261.   { { eval echo ""$as_me":${as_lineno-$LINENO}: "$ac_try""; } >&5
  3262.   (eval $ac_try) 2>&5
  3263.   ac_status=$?
  3264.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  3265.   test $ac_status = 0; }; }; then :;
  3266.       else
  3267.         cc_works_part=norun
  3268.       fi
  3269.     fi
  3270.   else
  3271.     cc_works_part=no
  3272.   fi
  3273.   if test "$cc_works_part" != yes; then
  3274.     echo "failed program was:" >&5
  3275.     cat conftest.c >&5
  3276.   fi
  3277.   rm -f conftest* a.out b.out a.exe a_out.exe
  3278.   case $cc_works_part in
  3279.     yes)
  3280.       ;;
  3281.     no)
  3282.       gmp_prog_cc_works="no, alloca array"
  3283.       ;;
  3284.     norun)
  3285.       gmp_prog_cc_works="no, alloca array, program does not run"
  3286.       ;;
  3287.   esac
  3288. fi
  3289.       ;;
  3290.     no)
  3291.       ;;
  3292.     norun)
  3293.       ;;
  3294.   esac
  3295. fi
  3296. if test "$gmp_prog_cc_works" = yes; then
  3297.   # remove anything that might look like compiler output to our "||" expression
  3298.   rm -f conftest* a.out b.out a.exe a_out.exe
  3299.   cat >conftest.c <<EOF
  3300. /* The following provokes an internal error from the assembler on
  3301.    power2-ibm-aix4.3.1.0.  gcc -mrios2 compiles to nabs+fcirz, and this
  3302.    results in "Internal error related to the source program domain".
  3303.    For reference it seems to be the combination of nabs+fcirz which is bad,
  3304.    not either alone.  This sort of thing occurs in mpz/get_str.c with the
  3305.    way double chars_per_bit_exactly is applied in MPN_SIZEINBASE.  Perhaps
  3306.    if that code changes to a scaled-integer style then we won't need this
  3307.    test.  */
  3308. double fp[1];
  3309. int x;
  3310. int f ()
  3311. {
  3312.   int a;
  3313.   a = (x >= 0 ? x : -x);
  3314.   return a * fp[0];
  3315. }
  3316. int main () { return 0; }
  3317. EOF
  3318.   echo "Test compile: abs int -> double conversion" >&5
  3319.   gmp_compile="$cc $cflags $cppflags $flag conftest.c >&5"
  3320.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  3321.   (eval $gmp_compile) 2>&5
  3322.   ac_status=$?
  3323.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  3324.   test $ac_status = 0; }; then
  3325.     cc_works_part=yes
  3326.     if test "$cross_compiling" = no; then
  3327.       if { ac_try='./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest'
  3328.   { { eval echo ""$as_me":${as_lineno-$LINENO}: "$ac_try""; } >&5
  3329.   (eval $ac_try) 2>&5
  3330.   ac_status=$?
  3331.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  3332.   test $ac_status = 0; }; }; then :;
  3333.       else
  3334.         cc_works_part=norun
  3335.       fi
  3336.     fi
  3337.   else
  3338.     cc_works_part=no
  3339.   fi
  3340.   if test "$cc_works_part" != yes; then
  3341.     echo "failed program was:" >&5
  3342.     cat conftest.c >&5
  3343.   fi
  3344.   rm -f conftest* a.out b.out a.exe a_out.exe
  3345.   case $cc_works_part in
  3346.     yes)
  3347.       ;;
  3348.     no)
  3349.       gmp_prog_cc_works="no, abs int -> double conversion"
  3350.       ;;
  3351.     norun)
  3352.       gmp_prog_cc_works="no, abs int -> double conversion, program does not run"
  3353.       ;;
  3354.   esac
  3355. fi
  3356. if test "$gmp_prog_cc_works" = yes; then
  3357.   # remove anything that might look like compiler output to our "||" expression
  3358.   rm -f conftest* a.out b.out a.exe a_out.exe
  3359.   cat >conftest.c <<EOF
  3360. /* The following provokes a segfault in the compiler on powerpc-apple-darwin.
  3361.    Extracted from tests/mpn/t-iord_u.c.  Causes Apple's gcc 3.3 build 1640 and
  3362.    1666 to segfault with e.g., -O2 -mpowerpc64.  */
  3363. #if defined (__GNUC__) && ! defined (__cplusplus)
  3364. typedef unsigned long long t1;typedef t1*t2;
  3365. static __inline__ t1 e(t2 rp,t2 up,int n,t1 v0)
  3366. {t1 c,x,r;int i;if(v0){c=1;for(i=1;i<n;i++){x=up[i];r=x+1;rp[i]=r;}}return c;}
  3367. f(){static const struct{t1 n;t1 src[9];t1 want[9];}d[]={{1,{0},{1}},};t1 got[9];int i;
  3368. for(i=0;i<1;i++){if(e(got,got,9,d[i].n)==0)h();g(i,d[i].src,d[i].n,got,d[i].want,9);if(d[i].n)h();}}
  3369. h(){}g(){}
  3370. #else
  3371. int dummy;
  3372. #endif
  3373. int main () { return 0; }
  3374. EOF
  3375.   echo "Test compile: long long reliability test 1" >&5
  3376.   gmp_compile="$cc $cflags $cppflags $flag conftest.c >&5"
  3377.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  3378.   (eval $gmp_compile) 2>&5
  3379.   ac_status=$?
  3380.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  3381.   test $ac_status = 0; }; then
  3382.     cc_works_part=yes
  3383.     if test "$cross_compiling" = no; then
  3384.       if { ac_try='./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest'
  3385.   { { eval echo ""$as_me":${as_lineno-$LINENO}: "$ac_try""; } >&5
  3386.   (eval $ac_try) 2>&5
  3387.   ac_status=$?
  3388.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  3389.   test $ac_status = 0; }; }; then :;
  3390.       else
  3391.         cc_works_part=norun
  3392.       fi
  3393.     fi
  3394.   else
  3395.     cc_works_part=no
  3396.   fi
  3397.   if test "$cc_works_part" != yes; then
  3398.     echo "failed program was:" >&5
  3399.     cat conftest.c >&5
  3400.   fi
  3401.   rm -f conftest* a.out b.out a.exe a_out.exe
  3402.   case $cc_works_part in
  3403.     yes)
  3404.       ;;
  3405.     no)
  3406.       gmp_prog_cc_works="no, long long reliability test 1"
  3407.       ;;
  3408.     norun)
  3409.       gmp_prog_cc_works="no, long long reliability test 1, program does not run"
  3410.       ;;
  3411.   esac
  3412. fi
  3413. if test "$gmp_prog_cc_works" = yes; then
  3414.   # remove anything that might look like compiler output to our "||" expression
  3415.   rm -f conftest* a.out b.out a.exe a_out.exe
  3416.   cat >conftest.c <<EOF
  3417. /* The following provokes an internal compiler error on powerpc-apple-darwin.
  3418.    Extracted from mpz/cfdiv_q_2exp.c.  Causes Apple's gcc 3.3 build 1640 and
  3419.    1666 to get an ICE with -O1 -mpowerpc64.  */
  3420. #if defined (__GNUC__) && ! defined (__cplusplus)
  3421. f(int u){int i;long long x;x=u?~0:0;if(x)for(i=0;i<9;i++);x&=g();if(x)g();}
  3422. g(){}
  3423. #else
  3424. int dummy;
  3425. #endif
  3426. int main () { return 0; }
  3427. EOF
  3428.   echo "Test compile: long long reliability test 2" >&5
  3429.   gmp_compile="$cc $cflags $cppflags $flag conftest.c >&5"
  3430.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  3431.   (eval $gmp_compile) 2>&5
  3432.   ac_status=$?
  3433.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  3434.   test $ac_status = 0; }; then
  3435.     cc_works_part=yes
  3436.     if test "$cross_compiling" = no; then
  3437.       if { ac_try='./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest'
  3438.   { { eval echo ""$as_me":${as_lineno-$LINENO}: "$ac_try""; } >&5
  3439.   (eval $ac_try) 2>&5
  3440.   ac_status=$?
  3441.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  3442.   test $ac_status = 0; }; }; then :;
  3443.       else
  3444.         cc_works_part=norun
  3445.       fi
  3446.     fi
  3447.   else
  3448.     cc_works_part=no
  3449.   fi
  3450.   if test "$cc_works_part" != yes; then
  3451.     echo "failed program was:" >&5
  3452.     cat conftest.c >&5
  3453.   fi
  3454.   rm -f conftest* a.out b.out a.exe a_out.exe
  3455.   case $cc_works_part in
  3456.     yes)
  3457.       ;;
  3458.     no)
  3459.       gmp_prog_cc_works="no, long long reliability test 2"
  3460.       ;;
  3461.     norun)
  3462.       gmp_prog_cc_works="no, long long reliability test 2, program does not run"
  3463.       ;;
  3464.   esac
  3465. fi
  3466. if test "$gmp_prog_cc_works" = yes; then
  3467.   # remove anything that might look like compiler output to our "||" expression
  3468.   rm -f conftest* a.out b.out a.exe a_out.exe
  3469.   cat >conftest.c <<EOF
  3470. /* The following is mis-compiled by HP ia-64 cc version
  3471.         cc: HP aC++/ANSI C B3910B A.05.55 [Dec 04 2003]
  3472.    under "cc +O3", both in +DD32 and +DD64 modes.  The mpn_lshift_com gets
  3473.    inlined and its return value somehow botched to be 0 instead of 1.  This
  3474.    arises in the real mpn_lshift_com in mul_fft.c.  A lower optimization
  3475.    level, like +O2 seems ok.  This code needs to be run to show the problem,
  3476.    but that's fine, the offending cc is a native-only compiler so we don't
  3477.    have to worry about cross compiling.  */
  3478. #if ! defined (__cplusplus)
  3479. unsigned long
  3480. lshift_com (rp, up, n, cnt)
  3481.   unsigned long *rp;
  3482.   unsigned long *up;
  3483.   long n;
  3484.   unsigned cnt;
  3485. {
  3486.   unsigned long retval, high_limb, low_limb;
  3487.   unsigned tnc;
  3488.   long i;
  3489.   tnc = 8 * sizeof (unsigned long) - cnt;
  3490.   low_limb = *up++;
  3491.   retval = low_limb >> tnc;
  3492.   high_limb = low_limb << cnt;
  3493.   for (i = n - 1; i != 0; i--)
  3494.     {
  3495.       low_limb = *up++;
  3496.       *rp++ = ~(high_limb | (low_limb >> tnc));
  3497.       high_limb = low_limb << cnt;
  3498.     }
  3499.   return retval;
  3500. }
  3501. int
  3502. main ()