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

数学计算

开发平台:

Unix_Linux

  1. {
  2.   unsigned long cy, rp[2], up[2];
  3.   up[0] = ~ 0L;
  4.   up[1] = 0;
  5.   cy = lshift_com (rp, up, 2L, 1);
  6.   if (cy != 1L)
  7.     return 1;
  8.   return 0;
  9. }
  10. #else
  11. int
  12. main ()
  13. {
  14.   return 0;
  15. }
  16. #endif
  17. EOF
  18.   echo "Test compile: mpn_lshift_com optimization" >&5
  19.   gmp_compile="$cc $cflags $cppflags $flag conftest.c >&5"
  20.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  21.   (eval $gmp_compile) 2>&5
  22.   ac_status=$?
  23.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  24.   test $ac_status = 0; }; then
  25.     cc_works_part=yes
  26.     if test "$cross_compiling" = no; then
  27.       if { ac_try='./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest'
  28.   { { eval echo ""$as_me":${as_lineno-$LINENO}: "$ac_try""; } >&5
  29.   (eval $ac_try) 2>&5
  30.   ac_status=$?
  31.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  32.   test $ac_status = 0; }; }; then :;
  33.       else
  34.         cc_works_part=norun
  35.       fi
  36.     fi
  37.   else
  38.     cc_works_part=no
  39.   fi
  40.   if test "$cc_works_part" != yes; then
  41.     echo "failed program was:" >&5
  42.     cat conftest.c >&5
  43.   fi
  44.   rm -f conftest* a.out b.out a.exe a_out.exe
  45.   case $cc_works_part in
  46.     yes)
  47.       ;;
  48.     no)
  49.       gmp_prog_cc_works="no, mpn_lshift_com optimization"
  50.       ;;
  51.     norun)
  52.       gmp_prog_cc_works="no, mpn_lshift_com optimization, program does not run"
  53.       ;;
  54.   esac
  55. fi
  56. if test "$gmp_prog_cc_works" = yes; then
  57.   # remove anything that might look like compiler output to our "||" expression
  58.   rm -f conftest* a.out b.out a.exe a_out.exe
  59.   cat >conftest.c <<EOF
  60. /* The following is mis-compiled by Intel ia-64 icc version 1.8 under
  61.     "icc -O3",  After several calls, the function writes parial garbage to
  62.     the result vector.  Perhaps relates to the chk.a.nc insn.  This code needs
  63.     to be run to show the problem, but that's fine, the offending cc is a
  64.     native-only compiler so we don't have to worry about cross compiling.  */
  65. #if ! defined (__cplusplus)
  66. #include <stdlib.h>
  67. void
  68. lshift_com (rp, up, n, cnt)
  69.   unsigned long *rp;
  70.   unsigned long *up;
  71.   long n;
  72.   unsigned cnt;
  73. {
  74.   unsigned long high_limb, low_limb;
  75.   unsigned tnc;
  76.   long i;
  77.   up += n;
  78.   rp += n;
  79.   tnc = 8 * sizeof (unsigned long) - cnt;
  80.   low_limb = *--up;
  81.   high_limb = low_limb << cnt;
  82.   for (i = n - 1; i != 0; i--)
  83.     {
  84.       low_limb = *--up;
  85.       *--rp = ~(high_limb | (low_limb >> tnc));
  86.       high_limb = low_limb << cnt;
  87.     }
  88.   *--rp = ~high_limb;
  89. }
  90. int
  91. main ()
  92. {
  93.   unsigned long *r, *r2;
  94.   unsigned long a[88 + 1];
  95.   long i;
  96.   for (i = 0; i < 88 + 1; i++)
  97.     a[i] = ~0L;
  98.   r = malloc (10000 * sizeof (unsigned long));
  99.   r2 = r;
  100.   for (i = 0; i < 528; i += 22)
  101.     {
  102.       lshift_com (r2, a,
  103.   i / (8 * sizeof (unsigned long)) + 1,
  104.   i % (8 * sizeof (unsigned long)));
  105.       r2 += 88 + 1;
  106.     }
  107.   if (r[2048] != 0 || r[2049] != 0 || r[2050] != 0 || r[2051] != 0 ||
  108.       r[2052] != 0 || r[2053] != 0 || r[2054] != 0)
  109.     abort ();
  110.   return 0;
  111. }
  112. #else
  113. int
  114. main ()
  115. {
  116.   return 0;
  117. }
  118. #endif
  119. EOF
  120.   echo "Test compile: mpn_lshift_com optimization 2" >&5
  121.   gmp_compile="$cc $cflags $cppflags $flag conftest.c >&5"
  122.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  123.   (eval $gmp_compile) 2>&5
  124.   ac_status=$?
  125.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  126.   test $ac_status = 0; }; then
  127.     cc_works_part=yes
  128.     if test "$cross_compiling" = no; then
  129.       if { ac_try='./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest'
  130.   { { eval echo ""$as_me":${as_lineno-$LINENO}: "$ac_try""; } >&5
  131.   (eval $ac_try) 2>&5
  132.   ac_status=$?
  133.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  134.   test $ac_status = 0; }; }; then :;
  135.       else
  136.         cc_works_part=norun
  137.       fi
  138.     fi
  139.   else
  140.     cc_works_part=no
  141.   fi
  142.   if test "$cc_works_part" != yes; then
  143.     echo "failed program was:" >&5
  144.     cat conftest.c >&5
  145.   fi
  146.   rm -f conftest* a.out b.out a.exe a_out.exe
  147.   case $cc_works_part in
  148.     yes)
  149.       ;;
  150.     no)
  151.       gmp_prog_cc_works="no, mpn_lshift_com optimization 2"
  152.       ;;
  153.     norun)
  154.       gmp_prog_cc_works="no, mpn_lshift_com optimization 2, program does not run"
  155.       ;;
  156.   esac
  157. fi
  158. # A certain _GLOBAL_OFFSET_TABLE_ problem in past versions of gas, tickled
  159. # by recent versions of gcc.
  160. #
  161. if test "$gmp_prog_cc_works" = yes; then
  162.   case $host in
  163.     i?86*-*-* | k[5-8]*-*-* | pentium*-*-* | athlon-*-* | viac3*-*-* | geode*-*-* | atom-*-*)
  164.       # this problem only arises in PIC code, so don't need to test when
  165.       # --disable-shared.  We don't necessarily have $enable_shared set to
  166.       # yes at this point, it will still be unset for the default (which is
  167.       # yes); hence the use of "!= no".
  168.       if test "$enable_shared" != no; then
  169.         echo "Testing gcc GOT with eax emitted" >&5
  170. cat >conftest.c <<EOF
  171. int foo;
  172. int bar () { return foo; }
  173. EOF
  174. tmp_got_emitted=no
  175. gmp_compile="$cc $cflags $cppflags $flag -fPIC -S conftest.c >&5 2>&1"
  176. if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  177.   (eval $gmp_compile) 2>&5
  178.   ac_status=$?
  179.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  180.   test $ac_status = 0; }; then
  181.   if grep "addl.*_GLOBAL_OFFSET_TABLE_.*eax" conftest.s >/dev/null; then
  182.     tmp_got_emitted=yes
  183.   fi
  184. fi
  185. rm -f conftest.*
  186. echo "Result: $tmp_got_emitted" >&5
  187. if test "$tmp_got_emitted" = yes; then
  188.   echo "Testing gas GOT with eax good" >&5
  189. cat >conftest.awk <<EOF
  190. BEGIN {
  191.   want[0]  = "001"
  192.   want[1]  = "043"
  193.   want[2]  = "105"
  194.   want[3]  = "147"
  195.   want[4]  = "211"
  196.   want[5]  = "253"
  197.   want[6]  = "315"
  198.   want[7]  = "357"
  199.   want[8]  = "005"
  200.   want[9]  = "002"
  201.   want[10] = "000"
  202.   want[11] = "000"
  203.   want[12] = "000"
  204.   want[13] = "376"
  205.   want[14] = "334"
  206.   want[15] = "272"
  207.   want[16] = "230"
  208.   want[17] = "166"
  209.   want[18] = "124"
  210.   want[19] = "062"
  211.   want[20] = "020"
  212.   result = "yes"
  213. }
  214. {
  215.   for (f = 2; f <= NF; f++)
  216.     {
  217.       for (i = 0; i < 20; i++)
  218.         got[i] = got[i+1];
  219.       got[20] = $f;
  220.       found = 1
  221.       for (i = 0; i < 21; i++)
  222.         if (got[i] != want[i])
  223.           {
  224.             found = 0
  225.             break
  226.           }
  227.       if (found)
  228.         {
  229.           result = "no"
  230.           exit
  231.         }
  232.     }
  233. }
  234. END {
  235.   print result
  236. }
  237. EOF
  238. cat >conftest.s <<EOF
  239. .text
  240. .byte 1, 35, 69, 103, 137, 171, 205, 239
  241. addl $_GLOBAL_OFFSET_TABLE_, %eax
  242. .byte 254, 220, 186, 152, 118, 84, 50, 16
  243. EOF
  244. tmp_got_good=yes
  245. gmp_compile="$cc $cflags $cppflags $flag -fPIC -o conftest.o -c conftest.s >&5 2>&1"
  246. if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  247.   (eval $gmp_compile) 2>&5
  248.   ac_status=$?
  249.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  250.   test $ac_status = 0; }; then
  251.   tmp_got_good=`od -b conftest.o | $AWK -f conftest.awk`
  252. fi
  253. rm -f conftest.*
  254. echo "Result: $tmp_got_good" >&5
  255. if test "$tmp_got_good" = no; then
  256.   gmp_prog_cc_works="no, bad gas GOT with eax"
  257. else
  258.   :
  259. fi
  260. else
  261.   :
  262. fi
  263.       fi
  264.       ;;
  265.   esac
  266. fi
  267. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $gmp_prog_cc_works" >&5
  268. $as_echo "$gmp_prog_cc_works" >&6; }
  269. case $gmp_prog_cc_works in
  270.   yes)
  271.     cflags="$cflags $flag"
  272.           break
  273.     ;;
  274.   *)
  275.     ;;
  276. esac
  277.       done
  278.     done
  279.   fi
  280.   ABI="$abi"
  281.   CC="$cc"
  282.   CFLAGS="$cflags"
  283.   CPPFLAGS="$cppflags"
  284.   # Could easily have this in config.h too, if desired.
  285.   ABI_nodots=`echo $ABI | sed 's/./_/'`
  286. echo "define_not_for_expansion(`HAVE_ABI_$ABI_nodots')" >> $gmp_tmpconfigm4p
  287.   # GMP_LDFLAGS substitution, selected according to ABI.
  288.   # These are needed on libgmp.la and libmp.la, but currently not on
  289.   # convenience libraries like tune/libspeed.la or mpz/libmpz.la.
  290.   #
  291.                             eval GMP_LDFLAGS="$${ccbase}${abi1}_ldflags"
  292.   test -n "$GMP_LDFLAGS" || eval GMP_LDFLAGS="$${ccbase}${abi1}_ldflags"
  293.   # extra_functions, selected according to ABI
  294.                     eval tmp="$extra_functions$abi1"
  295.   test -n "$tmp" || eval tmp="$extra_functions$abi2"
  296.   extra_functions="$tmp"
  297.   # Cycle counter, selected according to ABI.
  298.   #
  299.                     eval tmp="$SPEED_CYCLECOUNTER_OBJ$abi1"
  300.   test -n "$tmp" || eval tmp="$SPEED_CYCLECOUNTER_OBJ$abi2"
  301.   SPEED_CYCLECOUNTER_OBJ="$tmp"
  302.                     eval tmp="$cyclecounter_size$abi1"
  303.   test -n "$tmp" || eval tmp="$cyclecounter_size$abi2"
  304.   cyclecounter_size="$tmp"
  305.   if test -n "$SPEED_CYCLECOUNTER_OBJ"; then
  306. cat >>confdefs.h <<_ACEOF
  307. #define HAVE_SPEED_CYCLECOUNTER $cyclecounter_size
  308. _ACEOF
  309.   fi
  310.   # Calling conventions checking, selected according to ABI.
  311.   #
  312.                     eval tmp="$CALLING_CONVENTIONS_OBJS$abi1"
  313.   test -n "$tmp" || eval tmp="$CALLING_CONVENTIONS_OBJS$abi2"
  314.   CALLING_CONVENTIONS_OBJS="$tmp"
  315.   if test -n "$CALLING_CONVENTIONS_OBJS"; then
  316. $as_echo "#define HAVE_CALLING_CONVENTIONS 1" >>confdefs.h
  317.   fi
  318. fi
  319. # If the user gave an MPN_PATH, use that verbatim, otherwise choose
  320. # according to the ABI and add "generic".
  321. #
  322. if test -n "$MPN_PATH"; then
  323.   path="$MPN_PATH"
  324. else
  325.                     eval tmp="$path$abi1"
  326.   test -n "$tmp" || eval tmp="$path$abi2"
  327.   path="$tmp generic"
  328. fi
  329. # Long long limb setup for gmp.h.
  330. case $limb_chosen in
  331. longlong) DEFN_LONG_LONG_LIMB="#define _LONG_LONG_LIMB 1"    ;;
  332. *)        DEFN_LONG_LONG_LIMB="/* #undef _LONG_LONG_LIMB */" ;;
  333. esac
  334. # The C compiler and preprocessor, put into ANSI mode if possible.
  335. ac_ext=c
  336. ac_cpp='$CPP $CPPFLAGS'
  337. ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
  338. ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
  339. ac_compiler_gnu=$ac_cv_c_compiler_gnu
  340. if test -n "$ac_tool_prefix"; then
  341.   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
  342. set dummy ${ac_tool_prefix}gcc; ac_word=$2
  343. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
  344. $as_echo_n "checking for $ac_word... " >&6; }
  345. if test "${ac_cv_prog_CC+set}" = set; then :
  346.   $as_echo_n "(cached) " >&6
  347. else
  348.   if test -n "$CC"; then
  349.   ac_cv_prog_CC="$CC" # Let the user override the test.
  350. else
  351. as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
  352. for as_dir in $PATH
  353. do
  354.   IFS=$as_save_IFS
  355.   test -z "$as_dir" && as_dir=.
  356.     for ac_exec_ext in '' $ac_executable_extensions; do
  357.   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
  358.     ac_cv_prog_CC="${ac_tool_prefix}gcc"
  359.     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
  360.     break 2
  361.   fi
  362. done
  363.   done
  364. IFS=$as_save_IFS
  365. fi
  366. fi
  367. CC=$ac_cv_prog_CC
  368. if test -n "$CC"; then
  369.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
  370. $as_echo "$CC" >&6; }
  371. else
  372.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  373. $as_echo "no" >&6; }
  374. fi
  375. fi
  376. if test -z "$ac_cv_prog_CC"; then
  377.   ac_ct_CC=$CC
  378.   # Extract the first word of "gcc", so it can be a program name with args.
  379. set dummy gcc; ac_word=$2
  380. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
  381. $as_echo_n "checking for $ac_word... " >&6; }
  382. if test "${ac_cv_prog_ac_ct_CC+set}" = set; then :
  383.   $as_echo_n "(cached) " >&6
  384. else
  385.   if test -n "$ac_ct_CC"; then
  386.   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
  387. else
  388. as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
  389. for as_dir in $PATH
  390. do
  391.   IFS=$as_save_IFS
  392.   test -z "$as_dir" && as_dir=.
  393.     for ac_exec_ext in '' $ac_executable_extensions; do
  394.   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
  395.     ac_cv_prog_ac_ct_CC="gcc"
  396.     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
  397.     break 2
  398.   fi
  399. done
  400.   done
  401. IFS=$as_save_IFS
  402. fi
  403. fi
  404. ac_ct_CC=$ac_cv_prog_ac_ct_CC
  405. if test -n "$ac_ct_CC"; then
  406.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
  407. $as_echo "$ac_ct_CC" >&6; }
  408. else
  409.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  410. $as_echo "no" >&6; }
  411. fi
  412.   if test "x$ac_ct_CC" = x; then
  413.     CC=""
  414.   else
  415.     case $cross_compiling:$ac_tool_warned in
  416. yes:)
  417. { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
  418. $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
  419. ac_tool_warned=yes ;;
  420. esac
  421.     CC=$ac_ct_CC
  422.   fi
  423. else
  424.   CC="$ac_cv_prog_CC"
  425. fi
  426. if test -z "$CC"; then
  427.           if test -n "$ac_tool_prefix"; then
  428.     # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
  429. set dummy ${ac_tool_prefix}cc; ac_word=$2
  430. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
  431. $as_echo_n "checking for $ac_word... " >&6; }
  432. if test "${ac_cv_prog_CC+set}" = set; then :
  433.   $as_echo_n "(cached) " >&6
  434. else
  435.   if test -n "$CC"; then
  436.   ac_cv_prog_CC="$CC" # Let the user override the test.
  437. else
  438. as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
  439. for as_dir in $PATH
  440. do
  441.   IFS=$as_save_IFS
  442.   test -z "$as_dir" && as_dir=.
  443.     for ac_exec_ext in '' $ac_executable_extensions; do
  444.   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
  445.     ac_cv_prog_CC="${ac_tool_prefix}cc"
  446.     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
  447.     break 2
  448.   fi
  449. done
  450.   done
  451. IFS=$as_save_IFS
  452. fi
  453. fi
  454. CC=$ac_cv_prog_CC
  455. if test -n "$CC"; then
  456.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
  457. $as_echo "$CC" >&6; }
  458. else
  459.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  460. $as_echo "no" >&6; }
  461. fi
  462.   fi
  463. fi
  464. if test -z "$CC"; then
  465.   # Extract the first word of "cc", so it can be a program name with args.
  466. set dummy cc; ac_word=$2
  467. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
  468. $as_echo_n "checking for $ac_word... " >&6; }
  469. if test "${ac_cv_prog_CC+set}" = set; then :
  470.   $as_echo_n "(cached) " >&6
  471. else
  472.   if test -n "$CC"; then
  473.   ac_cv_prog_CC="$CC" # Let the user override the test.
  474. else
  475.   ac_prog_rejected=no
  476. as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
  477. for as_dir in $PATH
  478. do
  479.   IFS=$as_save_IFS
  480.   test -z "$as_dir" && as_dir=.
  481.     for ac_exec_ext in '' $ac_executable_extensions; do
  482.   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
  483.     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
  484.        ac_prog_rejected=yes
  485.        continue
  486.      fi
  487.     ac_cv_prog_CC="cc"
  488.     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
  489.     break 2
  490.   fi
  491. done
  492.   done
  493. IFS=$as_save_IFS
  494. if test $ac_prog_rejected = yes; then
  495.   # We found a bogon in the path, so make sure we never use it.
  496.   set dummy $ac_cv_prog_CC
  497.   shift
  498.   if test $# != 0; then
  499.     # We chose a different compiler from the bogus one.
  500.     # However, it has the same basename, so the bogon will be chosen
  501.     # first if we set CC to just the basename; use the full file name.
  502.     shift
  503.     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
  504.   fi
  505. fi
  506. fi
  507. fi
  508. CC=$ac_cv_prog_CC
  509. if test -n "$CC"; then
  510.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
  511. $as_echo "$CC" >&6; }
  512. else
  513.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  514. $as_echo "no" >&6; }
  515. fi
  516. fi
  517. if test -z "$CC"; then
  518.   if test -n "$ac_tool_prefix"; then
  519.   for ac_prog in cl.exe
  520.   do
  521.     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
  522. set dummy $ac_tool_prefix$ac_prog; ac_word=$2
  523. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
  524. $as_echo_n "checking for $ac_word... " >&6; }
  525. if test "${ac_cv_prog_CC+set}" = set; then :
  526.   $as_echo_n "(cached) " >&6
  527. else
  528.   if test -n "$CC"; then
  529.   ac_cv_prog_CC="$CC" # Let the user override the test.
  530. else
  531. as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
  532. for as_dir in $PATH
  533. do
  534.   IFS=$as_save_IFS
  535.   test -z "$as_dir" && as_dir=.
  536.     for ac_exec_ext in '' $ac_executable_extensions; do
  537.   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
  538.     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
  539.     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
  540.     break 2
  541.   fi
  542. done
  543.   done
  544. IFS=$as_save_IFS
  545. fi
  546. fi
  547. CC=$ac_cv_prog_CC
  548. if test -n "$CC"; then
  549.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
  550. $as_echo "$CC" >&6; }
  551. else
  552.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  553. $as_echo "no" >&6; }
  554. fi
  555.     test -n "$CC" && break
  556.   done
  557. fi
  558. if test -z "$CC"; then
  559.   ac_ct_CC=$CC
  560.   for ac_prog in cl.exe
  561. do
  562.   # Extract the first word of "$ac_prog", so it can be a program name with args.
  563. set dummy $ac_prog; ac_word=$2
  564. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
  565. $as_echo_n "checking for $ac_word... " >&6; }
  566. if test "${ac_cv_prog_ac_ct_CC+set}" = set; then :
  567.   $as_echo_n "(cached) " >&6
  568. else
  569.   if test -n "$ac_ct_CC"; then
  570.   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
  571. else
  572. as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
  573. for as_dir in $PATH
  574. do
  575.   IFS=$as_save_IFS
  576.   test -z "$as_dir" && as_dir=.
  577.     for ac_exec_ext in '' $ac_executable_extensions; do
  578.   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
  579.     ac_cv_prog_ac_ct_CC="$ac_prog"
  580.     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
  581.     break 2
  582.   fi
  583. done
  584.   done
  585. IFS=$as_save_IFS
  586. fi
  587. fi
  588. ac_ct_CC=$ac_cv_prog_ac_ct_CC
  589. if test -n "$ac_ct_CC"; then
  590.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
  591. $as_echo "$ac_ct_CC" >&6; }
  592. else
  593.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  594. $as_echo "no" >&6; }
  595. fi
  596.   test -n "$ac_ct_CC" && break
  597. done
  598.   if test "x$ac_ct_CC" = x; then
  599.     CC=""
  600.   else
  601.     case $cross_compiling:$ac_tool_warned in
  602. yes:)
  603. { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
  604. $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
  605. ac_tool_warned=yes ;;
  606. esac
  607.     CC=$ac_ct_CC
  608.   fi
  609. fi
  610. fi
  611. test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in `$ac_pwd':" >&5
  612. $as_echo "$as_me: error: in `$ac_pwd':" >&2;}
  613. as_fn_error "no acceptable C compiler found in $PATH
  614. See `config.log' for more details." "$LINENO" 5; }
  615. # Provide some information about the compiler.
  616. $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
  617. set X $ac_compile
  618. ac_compiler=$2
  619. for ac_option in --version -v -V -qversion; do
  620.   { { ac_try="$ac_compiler $ac_option >&5"
  621. case "(($ac_try" in
  622.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  623.   *) ac_try_echo=$ac_try;;
  624. esac
  625. eval ac_try_echo=""$as_me:${as_lineno-$LINENO}: $ac_try_echo""
  626. $as_echo "$ac_try_echo"; } >&5
  627.   (eval "$ac_compiler $ac_option >&5") 2>conftest.err
  628.   ac_status=$?
  629.   if test -s conftest.err; then
  630.     sed '10a
  631. ... rest of stderr output deleted ...
  632.          10q' conftest.err >conftest.er1
  633.     cat conftest.er1 >&5
  634.   fi
  635.   rm -f conftest.er1 conftest.err
  636.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  637.   test $ac_status = 0; }
  638. done
  639. cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  640. /* end confdefs.h.  */
  641. int
  642. main ()
  643. {
  644.   ;
  645.   return 0;
  646. }
  647. _ACEOF
  648. ac_clean_files_save=$ac_clean_files
  649. ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
  650. # Try to create an executable without -o first, disregard a.out.
  651. # It will help us diagnose broken compilers, and finding out an intuition
  652. # of exeext.
  653. { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
  654. $as_echo_n "checking whether the C compiler works... " >&6; }
  655. ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
  656. # The possible output files:
  657. ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
  658. ac_rmfiles=
  659. for ac_file in $ac_files
  660. do
  661.   case $ac_file in
  662.     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
  663.     * ) ac_rmfiles="$ac_rmfiles $ac_file";;
  664.   esac
  665. done
  666. rm -f $ac_rmfiles
  667. if { { ac_try="$ac_link_default"
  668. case "(($ac_try" in
  669.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  670.   *) ac_try_echo=$ac_try;;
  671. esac
  672. eval ac_try_echo=""$as_me:${as_lineno-$LINENO}: $ac_try_echo""
  673. $as_echo "$ac_try_echo"; } >&5
  674.   (eval "$ac_link_default") 2>&5
  675.   ac_status=$?
  676.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  677.   test $ac_status = 0; }; then :
  678.   # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
  679. # So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
  680. # in a Makefile.  We should not override ac_cv_exeext if it was cached,
  681. # so that the user can short-circuit this test for compilers unknown to
  682. # Autoconf.
  683. for ac_file in $ac_files ''
  684. do
  685.   test -f "$ac_file" || continue
  686.   case $ac_file in
  687.     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
  688. ;;
  689.     [ab].out )
  690. # We found the default executable, but exeext='' is most
  691. # certainly right.
  692. break;;
  693.     *.* )
  694. if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
  695. then :; else
  696.    ac_cv_exeext=`expr "$ac_file" : '[^.]*(..*)'`
  697. fi
  698. # We set ac_cv_exeext here because the later test for it is not
  699. # safe: cross compilers may not add the suffix if given an `-o'
  700. # argument, so we may need to know it at that point already.
  701. # Even if this section looks crufty: it has the advantage of
  702. # actually working.
  703. break;;
  704.     * )
  705. break;;
  706.   esac
  707. done
  708. test "$ac_cv_exeext" = no && ac_cv_exeext=
  709. else
  710.   ac_file=''
  711. fi
  712. if test -z "$ac_file"; then :
  713.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  714. $as_echo "no" >&6; }
  715. $as_echo "$as_me: failed program was:" >&5
  716. sed 's/^/| /' conftest.$ac_ext >&5
  717. { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in `$ac_pwd':" >&5
  718. $as_echo "$as_me: error: in `$ac_pwd':" >&2;}
  719. { as_fn_set_status 77
  720. as_fn_error "C compiler cannot create executables
  721. See `config.log' for more details." "$LINENO" 5; }; }
  722. else
  723.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
  724. $as_echo "yes" >&6; }
  725. fi
  726. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
  727. $as_echo_n "checking for C compiler default output file name... " >&6; }
  728. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
  729. $as_echo "$ac_file" >&6; }
  730. ac_exeext=$ac_cv_exeext
  731. rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
  732. ac_clean_files=$ac_clean_files_save
  733. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
  734. $as_echo_n "checking for suffix of executables... " >&6; }
  735. if { { ac_try="$ac_link"
  736. case "(($ac_try" in
  737.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  738.   *) ac_try_echo=$ac_try;;
  739. esac
  740. eval ac_try_echo=""$as_me:${as_lineno-$LINENO}: $ac_try_echo""
  741. $as_echo "$ac_try_echo"; } >&5
  742.   (eval "$ac_link") 2>&5
  743.   ac_status=$?
  744.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  745.   test $ac_status = 0; }; then :
  746.   # If both `conftest.exe' and `conftest' are `present' (well, observable)
  747. # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
  748. # work properly (i.e., refer to `conftest.exe'), while it won't with
  749. # `rm'.
  750. for ac_file in conftest.exe conftest conftest.*; do
  751.   test -f "$ac_file" || continue
  752.   case $ac_file in
  753.     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
  754.     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*(..*)'`
  755.   break;;
  756.     * ) break;;
  757.   esac
  758. done
  759. else
  760.   { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in `$ac_pwd':" >&5
  761. $as_echo "$as_me: error: in `$ac_pwd':" >&2;}
  762. as_fn_error "cannot compute suffix of executables: cannot compile and link
  763. See `config.log' for more details." "$LINENO" 5; }
  764. fi
  765. rm -f conftest conftest$ac_cv_exeext
  766. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
  767. $as_echo "$ac_cv_exeext" >&6; }
  768. rm -f conftest.$ac_ext
  769. EXEEXT=$ac_cv_exeext
  770. ac_exeext=$EXEEXT
  771. cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  772. /* end confdefs.h.  */
  773. #include <stdio.h>
  774. int
  775. main ()
  776. {
  777. FILE *f = fopen ("conftest.out", "w");
  778.  return ferror (f) || fclose (f) != 0;
  779.   ;
  780.   return 0;
  781. }
  782. _ACEOF
  783. ac_clean_files="$ac_clean_files conftest.out"
  784. # Check that the compiler produces executables we can run.  If not, either
  785. # the compiler is broken, or we cross compile.
  786. { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
  787. $as_echo_n "checking whether we are cross compiling... " >&6; }
  788. if test "$cross_compiling" != yes; then
  789.   { { ac_try="$ac_link"
  790. case "(($ac_try" in
  791.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  792.   *) ac_try_echo=$ac_try;;
  793. esac
  794. eval ac_try_echo=""$as_me:${as_lineno-$LINENO}: $ac_try_echo""
  795. $as_echo "$ac_try_echo"; } >&5
  796.   (eval "$ac_link") 2>&5
  797.   ac_status=$?
  798.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  799.   test $ac_status = 0; }
  800.   if { ac_try='./conftest$ac_cv_exeext'
  801.   { { case "(($ac_try" in
  802.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  803.   *) ac_try_echo=$ac_try;;
  804. esac
  805. eval ac_try_echo=""$as_me:${as_lineno-$LINENO}: $ac_try_echo""
  806. $as_echo "$ac_try_echo"; } >&5
  807.   (eval "$ac_try") 2>&5
  808.   ac_status=$?
  809.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  810.   test $ac_status = 0; }; }; then
  811.     cross_compiling=no
  812.   else
  813.     if test "$cross_compiling" = maybe; then
  814. cross_compiling=yes
  815.     else
  816. { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in `$ac_pwd':" >&5
  817. $as_echo "$as_me: error: in `$ac_pwd':" >&2;}
  818. as_fn_error "cannot run C compiled programs.
  819. If you meant to cross compile, use `--host'.
  820. See `config.log' for more details." "$LINENO" 5; }
  821.     fi
  822.   fi
  823. fi
  824. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
  825. $as_echo "$cross_compiling" >&6; }
  826. rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
  827. ac_clean_files=$ac_clean_files_save
  828. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
  829. $as_echo_n "checking for suffix of object files... " >&6; }
  830. if test "${ac_cv_objext+set}" = set; then :
  831.   $as_echo_n "(cached) " >&6
  832. else
  833.   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  834. /* end confdefs.h.  */
  835. int
  836. main ()
  837. {
  838.   ;
  839.   return 0;
  840. }
  841. _ACEOF
  842. rm -f conftest.o conftest.obj
  843. if { { ac_try="$ac_compile"
  844. case "(($ac_try" in
  845.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  846.   *) ac_try_echo=$ac_try;;
  847. esac
  848. eval ac_try_echo=""$as_me:${as_lineno-$LINENO}: $ac_try_echo""
  849. $as_echo "$ac_try_echo"; } >&5
  850.   (eval "$ac_compile") 2>&5
  851.   ac_status=$?
  852.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  853.   test $ac_status = 0; }; then :
  854.   for ac_file in conftest.o conftest.obj conftest.*; do
  855.   test -f "$ac_file" || continue;
  856.   case $ac_file in
  857.     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
  858.     *) ac_cv_objext=`expr "$ac_file" : '.*.(.*)'`
  859.        break;;
  860.   esac
  861. done
  862. else
  863.   $as_echo "$as_me: failed program was:" >&5
  864. sed 's/^/| /' conftest.$ac_ext >&5
  865. { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in `$ac_pwd':" >&5
  866. $as_echo "$as_me: error: in `$ac_pwd':" >&2;}
  867. as_fn_error "cannot compute suffix of object files: cannot compile
  868. See `config.log' for more details." "$LINENO" 5; }
  869. fi
  870. rm -f conftest.$ac_cv_objext conftest.$ac_ext
  871. fi
  872. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
  873. $as_echo "$ac_cv_objext" >&6; }
  874. OBJEXT=$ac_cv_objext
  875. ac_objext=$OBJEXT
  876. { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
  877. $as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
  878. if test "${ac_cv_c_compiler_gnu+set}" = set; then :
  879.   $as_echo_n "(cached) " >&6
  880. else
  881.   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  882. /* end confdefs.h.  */
  883. int
  884. main ()
  885. {
  886. #ifndef __GNUC__
  887.        choke me
  888. #endif
  889.   ;
  890.   return 0;
  891. }
  892. _ACEOF
  893. if ac_fn_c_try_compile "$LINENO"; then :
  894.   ac_compiler_gnu=yes
  895. else
  896.   ac_compiler_gnu=no
  897. fi
  898. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  899. ac_cv_c_compiler_gnu=$ac_compiler_gnu
  900. fi
  901. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
  902. $as_echo "$ac_cv_c_compiler_gnu" >&6; }
  903. if test $ac_compiler_gnu = yes; then
  904.   GCC=yes
  905. else
  906.   GCC=
  907. fi
  908. ac_test_CFLAGS=${CFLAGS+set}
  909. ac_save_CFLAGS=$CFLAGS
  910. { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
  911. $as_echo_n "checking whether $CC accepts -g... " >&6; }
  912. if test "${ac_cv_prog_cc_g+set}" = set; then :
  913.   $as_echo_n "(cached) " >&6
  914. else
  915.   ac_save_c_werror_flag=$ac_c_werror_flag
  916.    ac_c_werror_flag=yes
  917.    ac_cv_prog_cc_g=no
  918.    CFLAGS="-g"
  919.    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  920. /* end confdefs.h.  */
  921. int
  922. main ()
  923. {
  924.   ;
  925.   return 0;
  926. }
  927. _ACEOF
  928. if ac_fn_c_try_compile "$LINENO"; then :
  929.   ac_cv_prog_cc_g=yes
  930. else
  931.   CFLAGS=""
  932.       cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  933. /* end confdefs.h.  */
  934. int
  935. main ()
  936. {
  937.   ;
  938.   return 0;
  939. }
  940. _ACEOF
  941. if ac_fn_c_try_compile "$LINENO"; then :
  942. else
  943.   ac_c_werror_flag=$ac_save_c_werror_flag
  944.  CFLAGS="-g"
  945.  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  946. /* end confdefs.h.  */
  947. int
  948. main ()
  949. {
  950.   ;
  951.   return 0;
  952. }
  953. _ACEOF
  954. if ac_fn_c_try_compile "$LINENO"; then :
  955.   ac_cv_prog_cc_g=yes
  956. fi
  957. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  958. fi
  959. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  960. fi
  961. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  962.    ac_c_werror_flag=$ac_save_c_werror_flag
  963. fi
  964. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
  965. $as_echo "$ac_cv_prog_cc_g" >&6; }
  966. if test "$ac_test_CFLAGS" = set; then
  967.   CFLAGS=$ac_save_CFLAGS
  968. elif test $ac_cv_prog_cc_g = yes; then
  969.   if test "$GCC" = yes; then
  970.     CFLAGS="-g -O2"
  971.   else
  972.     CFLAGS="-g"
  973.   fi
  974. else
  975.   if test "$GCC" = yes; then
  976.     CFLAGS="-O2"
  977.   else
  978.     CFLAGS=
  979.   fi
  980. fi
  981. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
  982. $as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
  983. if test "${ac_cv_prog_cc_c89+set}" = set; then :
  984.   $as_echo_n "(cached) " >&6
  985. else
  986.   ac_cv_prog_cc_c89=no
  987. ac_save_CC=$CC
  988. cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  989. /* end confdefs.h.  */
  990. #include <stdarg.h>
  991. #include <stdio.h>
  992. #include <sys/types.h>
  993. #include <sys/stat.h>
  994. /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
  995. struct buf { int x; };
  996. FILE * (*rcsopen) (struct buf *, struct stat *, int);
  997. static char *e (p, i)
  998.      char **p;
  999.      int i;
  1000. {
  1001.   return p[i];
  1002. }
  1003. static char *f (char * (*g) (char **, int), char **p, ...)
  1004. {
  1005.   char *s;
  1006.   va_list v;
  1007.   va_start (v,p);
  1008.   s = g (p, va_arg (v,int));
  1009.   va_end (v);
  1010.   return s;
  1011. }
  1012. /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
  1013.    function prototypes and stuff, but not 'xHH' hex character constants.
  1014.    These don't provoke an error unfortunately, instead are silently treated
  1015.    as 'x'.  The following induces an error, until -std is added to get
  1016.    proper ANSI mode.  Curiously 'x00'!='x' always comes out true, for an
  1017.    array size at least.  It's necessary to write 'x00'==0 to get something
  1018.    that's true only with -std.  */
  1019. int osf4_cc_array ['x00' == 0 ? 1 : -1];
  1020. /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
  1021.    inside strings and character constants.  */
  1022. #define FOO(x) 'x'
  1023. int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
  1024. int test (int i, double x);
  1025. struct s1 {int (*f) (int a);};
  1026. struct s2 {int (*f) (double a);};
  1027. int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
  1028. int argc;
  1029. char **argv;
  1030. int
  1031. main ()
  1032. {
  1033. return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
  1034.   ;
  1035.   return 0;
  1036. }
  1037. _ACEOF
  1038. for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std 
  1039. -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
  1040. do
  1041.   CC="$ac_save_CC $ac_arg"
  1042.   if ac_fn_c_try_compile "$LINENO"; then :
  1043.   ac_cv_prog_cc_c89=$ac_arg
  1044. fi
  1045. rm -f core conftest.err conftest.$ac_objext
  1046.   test "x$ac_cv_prog_cc_c89" != "xno" && break
  1047. done
  1048. rm -f conftest.$ac_ext
  1049. CC=$ac_save_CC
  1050. fi
  1051. # AC_CACHE_VAL
  1052. case "x$ac_cv_prog_cc_c89" in
  1053.   x)
  1054.     { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
  1055. $as_echo "none needed" >&6; } ;;
  1056.   xno)
  1057.     { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
  1058. $as_echo "unsupported" >&6; } ;;
  1059.   *)
  1060.     CC="$CC $ac_cv_prog_cc_c89"
  1061.     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
  1062. $as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
  1063. esac
  1064. if test "x$ac_cv_prog_cc_c89" != xno; then :
  1065. fi
  1066. ac_ext=c
  1067. ac_cpp='$CPP $CPPFLAGS'
  1068. ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
  1069. ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
  1070. ac_compiler_gnu=$ac_cv_c_compiler_gnu
  1071.    case $ac_cv_prog_cc_stdc in #(
  1072.   no) :
  1073.     ac_cv_prog_cc_c99=no; ac_cv_prog_cc_c89=no ;; #(
  1074.   *) :
  1075.     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C99" >&5
  1076. $as_echo_n "checking for $CC option to accept ISO C99... " >&6; }
  1077. if test "${ac_cv_prog_cc_c99+set}" = set; then :
  1078.   $as_echo_n "(cached) " >&6
  1079. else
  1080.   ac_cv_prog_cc_c99=no
  1081. ac_save_CC=$CC
  1082. cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  1083. /* end confdefs.h.  */
  1084. #include <stdarg.h>
  1085. #include <stdbool.h>
  1086. #include <stdlib.h>
  1087. #include <wchar.h>
  1088. #include <stdio.h>
  1089. // Check varargs macros.  These examples are taken from C99 6.10.3.5.
  1090. #define debug(...) fprintf (stderr, __VA_ARGS__)
  1091. #define showlist(...) puts (#__VA_ARGS__)
  1092. #define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__))
  1093. static void
  1094. test_varargs_macros (void)
  1095. {
  1096.   int x = 1234;
  1097.   int y = 5678;
  1098.   debug ("Flag");
  1099.   debug ("X = %dn", x);
  1100.   showlist (The first, second, and third items.);
  1101.   report (x>y, "x is %d but y is %d", x, y);
  1102. }
  1103. // Check long long types.
  1104. #define BIG64 18446744073709551615ull
  1105. #define BIG32 4294967295ul
  1106. #define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0)
  1107. #if !BIG_OK
  1108.   your preprocessor is broken;
  1109. #endif
  1110. #if BIG_OK
  1111. #else
  1112.   your preprocessor is broken;
  1113. #endif
  1114. static long long int bignum = -9223372036854775807LL;
  1115. static unsigned long long int ubignum = BIG64;
  1116. struct incomplete_array
  1117. {
  1118.   int datasize;
  1119.   double data[];
  1120. };
  1121. struct named_init {
  1122.   int number;
  1123.   const wchar_t *name;
  1124.   double average;
  1125. };
  1126. typedef const char *ccp;
  1127. static inline int
  1128. test_restrict (ccp restrict text)
  1129. {
  1130.   // See if C++-style comments work.
  1131.   // Iterate through items via the restricted pointer.
  1132.   // Also check for declarations in for loops.
  1133.   for (unsigned int i = 0; *(text+i) != ''; ++i)
  1134.     continue;
  1135.   return 0;
  1136. }
  1137. // Check varargs and va_copy.
  1138. static void
  1139. test_varargs (const char *format, ...)
  1140. {
  1141.   va_list args;
  1142.   va_start (args, format);
  1143.   va_list args_copy;
  1144.   va_copy (args_copy, args);
  1145.   const char *str;
  1146.   int number;
  1147.   float fnumber;
  1148.   while (*format)
  1149.     {
  1150.       switch (*format++)
  1151. {
  1152. case 's': // string
  1153.   str = va_arg (args_copy, const char *);
  1154.   break;
  1155. case 'd': // int
  1156.   number = va_arg (args_copy, int);
  1157.   break;
  1158. case 'f': // float
  1159.   fnumber = va_arg (args_copy, double);
  1160.   break;
  1161. default:
  1162.   break;
  1163. }
  1164.     }
  1165.   va_end (args_copy);
  1166.   va_end (args);
  1167. }
  1168. int
  1169. main ()
  1170. {
  1171.   // Check bool.
  1172.   _Bool success = false;
  1173.   // Check restrict.
  1174.   if (test_restrict ("String literal") == 0)
  1175.     success = true;
  1176.   char *restrict newvar = "Another string";
  1177.   // Check varargs.
  1178.   test_varargs ("s, d' f .", "string", 65, 34.234);
  1179.   test_varargs_macros ();
  1180.   // Check flexible array members.
  1181.   struct incomplete_array *ia =
  1182.     malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10));
  1183.   ia->datasize = 10;
  1184.   for (int i = 0; i < ia->datasize; ++i)
  1185.     ia->data[i] = i * 1.234;
  1186.   // Check named initializers.
  1187.   struct named_init ni = {
  1188.     .number = 34,
  1189.     .name = L"Test wide string",
  1190.     .average = 543.34343,
  1191.   };
  1192.   ni.number = 58;
  1193.   int dynamic_array[ni.number];
  1194.   dynamic_array[ni.number - 1] = 543;
  1195.   // work around unused variable warnings
  1196.   return (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == 'x'
  1197.   || dynamic_array[ni.number - 1] != 543);
  1198.   ;
  1199.   return 0;
  1200. }
  1201. _ACEOF
  1202. for ac_arg in '' -std=gnu99 -std=c99 -c99 -AC99 -xc99=all -qlanglvl=extc99
  1203. do
  1204.   CC="$ac_save_CC $ac_arg"
  1205.   if ac_fn_c_try_compile "$LINENO"; then :
  1206.   ac_cv_prog_cc_c99=$ac_arg
  1207. fi
  1208. rm -f core conftest.err conftest.$ac_objext
  1209.   test "x$ac_cv_prog_cc_c99" != "xno" && break
  1210. done
  1211. rm -f conftest.$ac_ext
  1212. CC=$ac_save_CC
  1213. fi
  1214. # AC_CACHE_VAL
  1215. case "x$ac_cv_prog_cc_c99" in
  1216.   x)
  1217.     { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
  1218. $as_echo "none needed" >&6; } ;;
  1219.   xno)
  1220.     { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
  1221. $as_echo "unsupported" >&6; } ;;
  1222.   *)
  1223.     CC="$CC $ac_cv_prog_cc_c99"
  1224.     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5
  1225. $as_echo "$ac_cv_prog_cc_c99" >&6; } ;;
  1226. esac
  1227. if test "x$ac_cv_prog_cc_c99" != xno; then :
  1228.   ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99
  1229. else
  1230.   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
  1231. $as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
  1232. if test "${ac_cv_prog_cc_c89+set}" = set; then :
  1233.   $as_echo_n "(cached) " >&6
  1234. else
  1235.   ac_cv_prog_cc_c89=no
  1236. ac_save_CC=$CC
  1237. cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  1238. /* end confdefs.h.  */
  1239. #include <stdarg.h>
  1240. #include <stdio.h>
  1241. #include <sys/types.h>
  1242. #include <sys/stat.h>
  1243. /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
  1244. struct buf { int x; };
  1245. FILE * (*rcsopen) (struct buf *, struct stat *, int);
  1246. static char *e (p, i)
  1247.      char **p;
  1248.      int i;
  1249. {
  1250.   return p[i];
  1251. }
  1252. static char *f (char * (*g) (char **, int), char **p, ...)
  1253. {
  1254.   char *s;
  1255.   va_list v;
  1256.   va_start (v,p);
  1257.   s = g (p, va_arg (v,int));
  1258.   va_end (v);
  1259.   return s;
  1260. }
  1261. /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
  1262.    function prototypes and stuff, but not 'xHH' hex character constants.
  1263.    These don't provoke an error unfortunately, instead are silently treated
  1264.    as 'x'.  The following induces an error, until -std is added to get
  1265.    proper ANSI mode.  Curiously 'x00'!='x' always comes out true, for an
  1266.    array size at least.  It's necessary to write 'x00'==0 to get something
  1267.    that's true only with -std.  */
  1268. int osf4_cc_array ['x00' == 0 ? 1 : -1];
  1269. /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
  1270.    inside strings and character constants.  */
  1271. #define FOO(x) 'x'
  1272. int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
  1273. int test (int i, double x);
  1274. struct s1 {int (*f) (int a);};
  1275. struct s2 {int (*f) (double a);};
  1276. int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
  1277. int argc;
  1278. char **argv;
  1279. int
  1280. main ()
  1281. {
  1282. return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
  1283.   ;
  1284.   return 0;
  1285. }
  1286. _ACEOF
  1287. for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std 
  1288. -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
  1289. do
  1290.   CC="$ac_save_CC $ac_arg"
  1291.   if ac_fn_c_try_compile "$LINENO"; then :
  1292.   ac_cv_prog_cc_c89=$ac_arg
  1293. fi
  1294. rm -f core conftest.err conftest.$ac_objext
  1295.   test "x$ac_cv_prog_cc_c89" != "xno" && break
  1296. done
  1297. rm -f conftest.$ac_ext
  1298. CC=$ac_save_CC
  1299. fi
  1300. # AC_CACHE_VAL
  1301. case "x$ac_cv_prog_cc_c89" in
  1302.   x)
  1303.     { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
  1304. $as_echo "none needed" >&6; } ;;
  1305.   xno)
  1306.     { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
  1307. $as_echo "unsupported" >&6; } ;;
  1308.   *)
  1309.     CC="$CC $ac_cv_prog_cc_c89"
  1310.     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
  1311. $as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
  1312. esac
  1313. if test "x$ac_cv_prog_cc_c89" != xno; then :
  1314.   ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89
  1315. else
  1316.   ac_cv_prog_cc_stdc=no
  1317. fi
  1318. fi
  1319.  ;;
  1320. esac
  1321.   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO Standard C" >&5
  1322. $as_echo_n "checking for $CC option to accept ISO Standard C... " >&6; }
  1323.   if test "${ac_cv_prog_cc_stdc+set}" = set; then :
  1324.   $as_echo_n "(cached) " >&6
  1325. fi
  1326.   case $ac_cv_prog_cc_stdc in #(
  1327.   no) :
  1328.     { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
  1329. $as_echo "unsupported" >&6; } ;; #(
  1330.   '') :
  1331.     { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
  1332. $as_echo "none needed" >&6; } ;; #(
  1333.   *) :
  1334.     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_stdc" >&5
  1335. $as_echo "$ac_cv_prog_cc_stdc" >&6; } ;;
  1336. esac
  1337. ac_ext=c
  1338. ac_cpp='$CPP $CPPFLAGS'
  1339. ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
  1340. ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
  1341. ac_compiler_gnu=$ac_cv_c_compiler_gnu
  1342. { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
  1343. $as_echo_n "checking how to run the C preprocessor... " >&6; }
  1344. # On Suns, sometimes $CPP names a directory.
  1345. if test -n "$CPP" && test -d "$CPP"; then
  1346.   CPP=
  1347. fi
  1348. if test -z "$CPP"; then
  1349.   if test "${ac_cv_prog_CPP+set}" = set; then :
  1350.   $as_echo_n "(cached) " >&6
  1351. else
  1352.       # Double quotes because CPP needs to be expanded
  1353.     for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
  1354.     do
  1355.       ac_preproc_ok=false
  1356. for ac_c_preproc_warn_flag in '' yes
  1357. do
  1358.   # Use a header file that comes with gcc, so configuring glibc
  1359.   # with a fresh cross-compiler works.
  1360.   # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
  1361.   # <limits.h> exists even on freestanding compilers.
  1362.   # On the NeXT, cc -E runs the code through the compiler's parser,
  1363.   # not just through cpp. "Syntax error" is here to catch this case.
  1364.   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  1365. /* end confdefs.h.  */
  1366. #ifdef __STDC__
  1367. # include <limits.h>
  1368. #else
  1369. # include <assert.h>
  1370. #endif
  1371.      Syntax error
  1372. _ACEOF
  1373. if ac_fn_c_try_cpp "$LINENO"; then :
  1374. else
  1375.   # Broken: fails on valid input.
  1376. continue
  1377. fi
  1378. rm -f conftest.err conftest.$ac_ext
  1379.   # OK, works on sane cases.  Now check whether nonexistent headers
  1380.   # can be detected and how.
  1381.   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  1382. /* end confdefs.h.  */
  1383. #include <ac_nonexistent.h>
  1384. _ACEOF
  1385. if ac_fn_c_try_cpp "$LINENO"; then :
  1386.   # Broken: success on invalid input.
  1387. continue
  1388. else
  1389.   # Passes both tests.
  1390. ac_preproc_ok=:
  1391. break
  1392. fi
  1393. rm -f conftest.err conftest.$ac_ext
  1394. done
  1395. # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
  1396. rm -f conftest.err conftest.$ac_ext
  1397. if $ac_preproc_ok; then :
  1398.   break
  1399. fi
  1400.     done
  1401.     ac_cv_prog_CPP=$CPP
  1402. fi
  1403.   CPP=$ac_cv_prog_CPP
  1404. else
  1405.   ac_cv_prog_CPP=$CPP
  1406. fi
  1407. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
  1408. $as_echo "$CPP" >&6; }
  1409. ac_preproc_ok=false
  1410. for ac_c_preproc_warn_flag in '' yes
  1411. do
  1412.   # Use a header file that comes with gcc, so configuring glibc
  1413.   # with a fresh cross-compiler works.
  1414.   # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
  1415.   # <limits.h> exists even on freestanding compilers.
  1416.   # On the NeXT, cc -E runs the code through the compiler's parser,
  1417.   # not just through cpp. "Syntax error" is here to catch this case.
  1418.   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  1419. /* end confdefs.h.  */
  1420. #ifdef __STDC__
  1421. # include <limits.h>
  1422. #else
  1423. # include <assert.h>
  1424. #endif
  1425.      Syntax error
  1426. _ACEOF
  1427. if ac_fn_c_try_cpp "$LINENO"; then :
  1428. else
  1429.   # Broken: fails on valid input.
  1430. continue
  1431. fi
  1432. rm -f conftest.err conftest.$ac_ext
  1433.   # OK, works on sane cases.  Now check whether nonexistent headers
  1434.   # can be detected and how.
  1435.   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  1436. /* end confdefs.h.  */
  1437. #include <ac_nonexistent.h>
  1438. _ACEOF
  1439. if ac_fn_c_try_cpp "$LINENO"; then :
  1440.   # Broken: success on invalid input.
  1441. continue
  1442. else
  1443.   # Passes both tests.
  1444. ac_preproc_ok=:
  1445. break
  1446. fi
  1447. rm -f conftest.err conftest.$ac_ext
  1448. done
  1449. # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
  1450. rm -f conftest.err conftest.$ac_ext
  1451. if $ac_preproc_ok; then :
  1452. else
  1453.   { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in `$ac_pwd':" >&5
  1454. $as_echo "$as_me: error: in `$ac_pwd':" >&2;}
  1455. as_fn_error "C preprocessor "$CPP" fails sanity check
  1456. See `config.log' for more details." "$LINENO" 5; }
  1457. fi
  1458. ac_ext=c
  1459. ac_cpp='$CPP $CPPFLAGS'
  1460. ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
  1461. ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
  1462. ac_compiler_gnu=$ac_cv_c_compiler_gnu
  1463. case $ac_cv_prog_cc_stdc in
  1464.   no)
  1465.     ;;
  1466.   *)
  1467.     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  1468. /* end confdefs.h.  */
  1469. #define __GMP_WITHIN_CONFIGURE 1   /* ignore template stuff */
  1470. #define GMP_NAIL_BITS $GMP_NAIL_BITS
  1471. #define GMP_LIMB_BITS 123
  1472. $DEFN_LONG_LONG_LIMB
  1473. #include "$srcdir/gmp-h.in"
  1474. #if ! __GMP_HAVE_PROTOTYPES
  1475. die die die
  1476. #endif
  1477. int
  1478. main ()
  1479. {
  1480.   ;
  1481.   return 0;
  1482. }
  1483. _ACEOF
  1484. if ac_fn_c_try_compile "$LINENO"; then :
  1485. else
  1486.   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: gmp.h doesnt recognise compiler as ANSI, prototypes and "const" will be unavailable" >&5
  1487. $as_echo "$as_me: WARNING: gmp.h doesnt recognise compiler as ANSI, prototypes and "const" will be unavailable" >&2;}
  1488. fi
  1489. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  1490.     ;;
  1491. esac
  1492. # The C compiler on the build system, and associated tests.
  1493. if test -n "$CC_FOR_BUILD"; then
  1494.   { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system compiler $CC_FOR_BUILD" >&5
  1495. $as_echo_n "checking build system compiler $CC_FOR_BUILD... " >&6; }
  1496. # remove anything that might look like compiler output to our "||" expression
  1497. rm -f conftest* a.out b.out a.exe a_out.exe
  1498. cat >conftest.c <<EOF
  1499. int
  1500. main ()
  1501. {
  1502.   exit(0);
  1503. }
  1504. EOF
  1505. gmp_compile="$CC_FOR_BUILD conftest.c"
  1506. cc_for_build_works=no
  1507. if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  1508.   (eval $gmp_compile) 2>&5
  1509.   ac_status=$?
  1510.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  1511.   test $ac_status = 0; }; then
  1512.   if (./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest) >&5 2>&1; then
  1513.     cc_for_build_works=yes
  1514.   fi
  1515. fi
  1516. rm -f conftest* a.out b.out a.exe a_out.exe
  1517. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $cc_for_build_works" >&5
  1518. $as_echo "$cc_for_build_works" >&6; }
  1519. if test "$cc_for_build_works" = yes; then
  1520.   :
  1521. else
  1522.   as_fn_error "Specified CC_FOR_BUILD doesn't seem to work" "$LINENO" 5
  1523. fi
  1524. elif test -n "$HOST_CC"; then
  1525.   { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system compiler $HOST_CC" >&5
  1526. $as_echo_n "checking build system compiler $HOST_CC... " >&6; }
  1527. # remove anything that might look like compiler output to our "||" expression
  1528. rm -f conftest* a.out b.out a.exe a_out.exe
  1529. cat >conftest.c <<EOF
  1530. int
  1531. main ()
  1532. {
  1533.   exit(0);
  1534. }
  1535. EOF
  1536. gmp_compile="$HOST_CC conftest.c"
  1537. cc_for_build_works=no
  1538. if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  1539.   (eval $gmp_compile) 2>&5
  1540.   ac_status=$?
  1541.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  1542.   test $ac_status = 0; }; then
  1543.   if (./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest) >&5 2>&1; then
  1544.     cc_for_build_works=yes
  1545.   fi
  1546. fi
  1547. rm -f conftest* a.out b.out a.exe a_out.exe
  1548. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $cc_for_build_works" >&5
  1549. $as_echo "$cc_for_build_works" >&6; }
  1550. if test "$cc_for_build_works" = yes; then
  1551.   CC_FOR_BUILD=$HOST_CC
  1552. else
  1553.   as_fn_error "Specified HOST_CC doesn't seem to work" "$LINENO" 5
  1554. fi
  1555. else
  1556.   for i in "$CC" "$CC $CFLAGS $CPPFLAGS" cc gcc c89 c99; do
  1557.     { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system compiler $i" >&5
  1558. $as_echo_n "checking build system compiler $i... " >&6; }
  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. int
  1563. main ()
  1564. {
  1565.   exit(0);
  1566. }
  1567. EOF
  1568. gmp_compile="$i conftest.c"
  1569. cc_for_build_works=no
  1570. if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  1571.   (eval $gmp_compile) 2>&5
  1572.   ac_status=$?
  1573.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  1574.   test $ac_status = 0; }; then
  1575.   if (./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest) >&5 2>&1; then
  1576.     cc_for_build_works=yes
  1577.   fi
  1578. fi
  1579. rm -f conftest* a.out b.out a.exe a_out.exe
  1580. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $cc_for_build_works" >&5
  1581. $as_echo "$cc_for_build_works" >&6; }
  1582. if test "$cc_for_build_works" = yes; then
  1583.   CC_FOR_BUILD=$i
  1584.        break
  1585. else
  1586.   :
  1587. fi
  1588.   done
  1589.   if test -z "$CC_FOR_BUILD"; then
  1590.     as_fn_error "Cannot find a build system compiler" "$LINENO" 5
  1591.   fi
  1592. fi
  1593. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for build system preprocessor" >&5
  1594. $as_echo_n "checking for build system preprocessor... " >&6; }
  1595. if test -z "$CPP_FOR_BUILD"; then
  1596.   if test "${gmp_cv_prog_cpp_for_build+set}" = set; then :
  1597.   $as_echo_n "(cached) " >&6
  1598. else
  1599.   cat >conftest.c <<EOF
  1600. #define FOO BAR
  1601. EOF
  1602.   for i in "$CC_FOR_BUILD -E" "$CC_FOR_BUILD -E -traditional-cpp" "/lib/cpp"; do
  1603.     gmp_compile="$i conftest.c"
  1604.     if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  1605.   (eval $gmp_compile) 2>&5
  1606.   ac_status=$?
  1607.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  1608.   test $ac_status = 0; } >&5 2>&1; then
  1609.       gmp_cv_prog_cpp_for_build=$i
  1610.       break
  1611.     fi
  1612.   done
  1613.   rm -f conftest* a.out b.out a.exe a_out.exe
  1614.   if test -z "$gmp_cv_prog_cpp_for_build"; then
  1615.     as_fn_error "Cannot find build system C preprocessor." "$LINENO" 5
  1616.   fi
  1617. fi
  1618.   CPP_FOR_BUILD=$gmp_cv_prog_cpp_for_build
  1619. fi
  1620. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP_FOR_BUILD" >&5
  1621. $as_echo "$CPP_FOR_BUILD" >&6; }
  1622. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for build system executable suffix" >&5
  1623. $as_echo_n "checking for build system executable suffix... " >&6; }
  1624. if test "${gmp_cv_prog_exeext_for_build+set}" = set; then :
  1625.   $as_echo_n "(cached) " >&6
  1626. else
  1627.   cat >conftest.c <<EOF
  1628. int
  1629. main ()
  1630. {
  1631.   exit (0);
  1632. }
  1633. EOF
  1634. for i in .exe ,ff8 ""; do
  1635.   gmp_compile="$CC_FOR_BUILD conftest.c -o conftest$i"
  1636.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  1637.   (eval $gmp_compile) 2>&5
  1638.   ac_status=$?
  1639.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  1640.   test $ac_status = 0; }; then
  1641.     if (./conftest) 2>&5; then
  1642.       gmp_cv_prog_exeext_for_build=$i
  1643.       break
  1644.     fi
  1645.   fi
  1646. done
  1647. rm -f conftest*
  1648. if test "${gmp_cv_prog_exeext_for_build+set}" != set; then
  1649.   as_fn_error "Cannot determine executable suffix" "$LINENO" 5
  1650. fi
  1651. fi
  1652. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $gmp_cv_prog_exeext_for_build" >&5
  1653. $as_echo "$gmp_cv_prog_exeext_for_build" >&6; }
  1654. EXEEXT_FOR_BUILD=$gmp_cv_prog_exeext_for_build
  1655. { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether build system compiler is ANSI" >&5
  1656. $as_echo_n "checking whether build system compiler is ANSI... " >&6; }
  1657. if test "${gmp_cv_c_for_build_ansi+set}" = set; then :
  1658.   $as_echo_n "(cached) " >&6
  1659. else
  1660.   cat >conftest.c <<EOF
  1661. int
  1662. main (int argc, char **argv)
  1663. {
  1664.   exit(0);
  1665. }
  1666. EOF
  1667. gmp_compile="$CC_FOR_BUILD conftest.c"
  1668. if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  1669.   (eval $gmp_compile) 2>&5
  1670.   ac_status=$?
  1671.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  1672.   test $ac_status = 0; }; then
  1673.   gmp_cv_c_for_build_ansi=yes
  1674. else
  1675.   gmp_cv_c_for_build_ansi=no
  1676. fi
  1677. rm -f conftest* a.out b.out a.exe a_out.exe
  1678. fi
  1679. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $gmp_cv_c_for_build_ansi" >&5
  1680. $as_echo "$gmp_cv_c_for_build_ansi" >&6; }
  1681. if test "$gmp_cv_c_for_build_ansi" = yes; then
  1682.   U_FOR_BUILD=
  1683. else
  1684.   U_FOR_BUILD=_
  1685. fi
  1686. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for build system compiler math library" >&5
  1687. $as_echo_n "checking for build system compiler math library... " >&6; }
  1688. if test "${gmp_cv_check_libm_for_build+set}" = set; then :
  1689.   $as_echo_n "(cached) " >&6
  1690. else
  1691.   cat >conftest.c <<EOF
  1692. int
  1693. main ()
  1694. {
  1695.   exit(0);
  1696. }
  1697. double d;
  1698. double
  1699. foo ()
  1700. {
  1701.   return log (d);
  1702. }
  1703. EOF
  1704. gmp_compile="$CC_FOR_BUILD conftest.c -lm"
  1705. if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_compile""; } >&5
  1706.   (eval $gmp_compile) 2>&5
  1707.   ac_status=$?
  1708.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  1709.   test $ac_status = 0; }; then
  1710.   gmp_cv_check_libm_for_build=-lm
  1711. else
  1712.   gmp_cv_check_libm_for_build=no
  1713. fi
  1714. rm -f conftest* a.out b.out a.exe a_out.exe
  1715. fi
  1716. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $gmp_cv_check_libm_for_build" >&5
  1717. $as_echo "$gmp_cv_check_libm_for_build" >&6; }
  1718. case $gmp_cv_check_libm_for_build in
  1719.   yes) LIBM_FOR_BUILD=-lm
  1720.  ;;
  1721.   no)  LIBM_FOR_BUILD= ;;
  1722.   *)   LIBM_FOR_BUILD=$gmp_cv_check_libm_for_build ;;
  1723. esac
  1724. # How to assemble, used with CFLAGS etc, see mpn/Makeasm.am.
  1725. # Using the compiler is a lot easier than figuring out how to invoke the
  1726. # assembler directly.
  1727. #
  1728. test -n "$CCAS" || CCAS="$CC -c"
  1729. # The C++ compiler, if desired.
  1730. want_cxx=no
  1731. if test $enable_cxx != no; then
  1732.   test_CXXFLAGS=${CXXFLAGS+set}
  1733.   ac_ext=cpp
  1734. ac_cpp='$CXXCPP $CPPFLAGS'
  1735. ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
  1736. ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
  1737. ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
  1738. if test -z "$CXX"; then
  1739.   if test -n "$CCC"; then
  1740.     CXX=$CCC
  1741.   else
  1742.     if test -n "$ac_tool_prefix"; then
  1743.   for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
  1744.   do
  1745.     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
  1746. set dummy $ac_tool_prefix$ac_prog; ac_word=$2
  1747. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
  1748. $as_echo_n "checking for $ac_word... " >&6; }
  1749. if test "${ac_cv_prog_CXX+set}" = set; then :
  1750.   $as_echo_n "(cached) " >&6
  1751. else
  1752.   if test -n "$CXX"; then
  1753.   ac_cv_prog_CXX="$CXX" # Let the user override the test.
  1754. else
  1755. as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
  1756. for as_dir in $PATH
  1757. do
  1758.   IFS=$as_save_IFS
  1759.   test -z "$as_dir" && as_dir=.
  1760.     for ac_exec_ext in '' $ac_executable_extensions; do
  1761.   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
  1762.     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
  1763.     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
  1764.     break 2
  1765.   fi
  1766. done
  1767.   done
  1768. IFS=$as_save_IFS
  1769. fi
  1770. fi
  1771. CXX=$ac_cv_prog_CXX
  1772. if test -n "$CXX"; then
  1773.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
  1774. $as_echo "$CXX" >&6; }
  1775. else
  1776.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  1777. $as_echo "no" >&6; }
  1778. fi
  1779.     test -n "$CXX" && break
  1780.   done
  1781. fi
  1782. if test -z "$CXX"; then
  1783.   ac_ct_CXX=$CXX
  1784.   for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
  1785. do
  1786.   # Extract the first word of "$ac_prog", so it can be a program name with args.
  1787. set dummy $ac_prog; ac_word=$2
  1788. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
  1789. $as_echo_n "checking for $ac_word... " >&6; }
  1790. if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then :
  1791.   $as_echo_n "(cached) " >&6
  1792. else
  1793.   if test -n "$ac_ct_CXX"; then
  1794.   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
  1795. else
  1796. as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
  1797. for as_dir in $PATH
  1798. do
  1799.   IFS=$as_save_IFS
  1800.   test -z "$as_dir" && as_dir=.
  1801.     for ac_exec_ext in '' $ac_executable_extensions; do
  1802.   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
  1803.     ac_cv_prog_ac_ct_CXX="$ac_prog"
  1804.     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
  1805.     break 2
  1806.   fi
  1807. done
  1808.   done
  1809. IFS=$as_save_IFS
  1810. fi
  1811. fi
  1812. ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
  1813. if test -n "$ac_ct_CXX"; then
  1814.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
  1815. $as_echo "$ac_ct_CXX" >&6; }
  1816. else
  1817.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  1818. $as_echo "no" >&6; }
  1819. fi
  1820.   test -n "$ac_ct_CXX" && break
  1821. done
  1822.   if test "x$ac_ct_CXX" = x; then
  1823.     CXX="g++"
  1824.   else
  1825.     case $cross_compiling:$ac_tool_warned in
  1826. yes:)
  1827. { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
  1828. $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
  1829. ac_tool_warned=yes ;;
  1830. esac
  1831.     CXX=$ac_ct_CXX
  1832.   fi
  1833. fi
  1834.   fi
  1835. fi
  1836. # Provide some information about the compiler.
  1837. $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
  1838. set X $ac_compile
  1839. ac_compiler=$2
  1840. for ac_option in --version -v -V -qversion; do
  1841.   { { ac_try="$ac_compiler $ac_option >&5"
  1842. case "(($ac_try" in
  1843.   *"* | *`* | *\*) ac_try_echo=$ac_try;;
  1844.   *) ac_try_echo=$ac_try;;
  1845. esac
  1846. eval ac_try_echo=""$as_me:${as_lineno-$LINENO}: $ac_try_echo""
  1847. $as_echo "$ac_try_echo"; } >&5
  1848.   (eval "$ac_compiler $ac_option >&5") 2>conftest.err
  1849.   ac_status=$?
  1850.   if test -s conftest.err; then
  1851.     sed '10a
  1852. ... rest of stderr output deleted ...
  1853.          10q' conftest.err >conftest.er1
  1854.     cat conftest.er1 >&5
  1855.   fi
  1856.   rm -f conftest.er1 conftest.err
  1857.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  1858.   test $ac_status = 0; }
  1859. done
  1860. { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
  1861. $as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
  1862. if test "${ac_cv_cxx_compiler_gnu+set}" = set; then :
  1863.   $as_echo_n "(cached) " >&6
  1864. else
  1865.   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  1866. /* end confdefs.h.  */
  1867. int
  1868. main ()
  1869. {
  1870. #ifndef __GNUC__
  1871.        choke me
  1872. #endif
  1873.   ;
  1874.   return 0;
  1875. }
  1876. _ACEOF
  1877. if ac_fn_cxx_try_compile "$LINENO"; then :
  1878.   ac_compiler_gnu=yes
  1879. else
  1880.   ac_compiler_gnu=no
  1881. fi
  1882. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  1883. ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
  1884. fi
  1885. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
  1886. $as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
  1887. if test $ac_compiler_gnu = yes; then
  1888.   GXX=yes
  1889. else
  1890.   GXX=
  1891. fi
  1892. ac_test_CXXFLAGS=${CXXFLAGS+set}
  1893. ac_save_CXXFLAGS=$CXXFLAGS
  1894. { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
  1895. $as_echo_n "checking whether $CXX accepts -g... " >&6; }
  1896. if test "${ac_cv_prog_cxx_g+set}" = set; then :
  1897.   $as_echo_n "(cached) " >&6
  1898. else
  1899.   ac_save_cxx_werror_flag=$ac_cxx_werror_flag
  1900.    ac_cxx_werror_flag=yes
  1901.    ac_cv_prog_cxx_g=no
  1902.    CXXFLAGS="-g"
  1903.    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  1904. /* end confdefs.h.  */
  1905. int
  1906. main ()
  1907. {
  1908.   ;
  1909.   return 0;
  1910. }
  1911. _ACEOF
  1912. if ac_fn_cxx_try_compile "$LINENO"; then :
  1913.   ac_cv_prog_cxx_g=yes
  1914. else
  1915.   CXXFLAGS=""
  1916.       cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  1917. /* end confdefs.h.  */
  1918. int
  1919. main ()
  1920. {
  1921.   ;
  1922.   return 0;
  1923. }
  1924. _ACEOF
  1925. if ac_fn_cxx_try_compile "$LINENO"; then :
  1926. else
  1927.   ac_cxx_werror_flag=$ac_save_cxx_werror_flag
  1928.  CXXFLAGS="-g"
  1929.  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  1930. /* end confdefs.h.  */
  1931. int
  1932. main ()
  1933. {
  1934.   ;
  1935.   return 0;
  1936. }
  1937. _ACEOF
  1938. if ac_fn_cxx_try_compile "$LINENO"; then :
  1939.   ac_cv_prog_cxx_g=yes
  1940. fi
  1941. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  1942. fi
  1943. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  1944. fi
  1945. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  1946.    ac_cxx_werror_flag=$ac_save_cxx_werror_flag
  1947. fi
  1948. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
  1949. $as_echo "$ac_cv_prog_cxx_g" >&6; }
  1950. if test "$ac_test_CXXFLAGS" = set; then
  1951.   CXXFLAGS=$ac_save_CXXFLAGS
  1952. elif test $ac_cv_prog_cxx_g = yes; then
  1953.   if test "$GXX" = yes; then
  1954.     CXXFLAGS="-g -O2"
  1955.   else
  1956.     CXXFLAGS="-g"
  1957.   fi
  1958. else
  1959.   if test "$GXX" = yes; then
  1960.     CXXFLAGS="-O2"
  1961.   else
  1962.     CXXFLAGS=
  1963.   fi
  1964. fi
  1965. ac_ext=c
  1966. ac_cpp='$CPP $CPPFLAGS'
  1967. ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
  1968. ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
  1969. ac_compiler_gnu=$ac_cv_c_compiler_gnu
  1970.   echo "CXXFLAGS chosen by autoconf: $CXXFLAGS" >&5
  1971.   cxxflags_ac_prog_cxx=$CXXFLAGS
  1972.   cxxflags_list=ac_prog_cxx
  1973.   # If the user didn't specify $CXXFLAGS, then try $CFLAGS, with -g removed
  1974.   # if AC_PROG_CXX thinks that doesn't work.  $CFLAGS stands a good chance
  1975.   # of working, eg. on a GNU system where CC=gcc and CXX=g++.
  1976.   #
  1977.   if test "$test_CXXFLAGS" != set; then
  1978.     cxxflags_cflags=$CFLAGS
  1979.     cxxflags_list="cflags $cxxflags_list"
  1980.     if test "$ac_prog_cxx_g" = no; then
  1981.       cxxflags_cflags=`echo "$cxxflags_cflags" | sed -e 's/ -g //' -e 's/^-g //' -e 's/ -g$//'`
  1982.     fi
  1983.   fi
  1984.   # See if the C++ compiler works.  If the user specified CXXFLAGS then all
  1985.   # we're doing is checking whether AC_PROG_CXX succeeded, since it doesn't
  1986.   # give a fatal error, just leaves CXX set to a default g++.  If on the
  1987.   # other hand the user didn't specify CXXFLAGS then we get to try here our
  1988.   # $cxxflags_list alternatives.
  1989.   #
  1990.   # Automake includes $CPPFLAGS in a C++ compile, so we do the same here.
  1991.   #
  1992.   for cxxflags_choice in $cxxflags_list; do
  1993.     eval CXXFLAGS="$cxxflags_$cxxflags_choice"
  1994.     { $as_echo "$as_me:${as_lineno-$LINENO}: checking C++ compiler $CXX $CPPFLAGS $CXXFLAGS" >&5
  1995. $as_echo_n "checking C++ compiler $CXX $CPPFLAGS $CXXFLAGS... " >&6; }
  1996. gmp_prog_cxx_works=yes
  1997. # start with a plain "main()", then go on to further checks
  1998. if test "$gmp_prog_cxx_works" = yes; then
  1999.   # remove anything that might look like compiler output to our "||" expression
  2000.   rm -f conftest* a.out b.out a.exe a_out.exe
  2001.   cat >conftest.cc <<EOF
  2002. int main (void) { return 0; }
  2003. EOF
  2004.   echo "Test compile: " >&5
  2005.   gmp_cxxcompile="$CXX $CPPFLAGS $CXXFLAGS conftest.cc >&5"
  2006.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_cxxcompile""; } >&5
  2007.   (eval $gmp_cxxcompile) 2>&5
  2008.   ac_status=$?
  2009.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2010.   test $ac_status = 0; }; then
  2011.     if test "$cross_compiling" = no; then
  2012.       if { ac_try='./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest'
  2013.   { { eval echo ""$as_me":${as_lineno-$LINENO}: "$ac_try""; } >&5
  2014.   (eval $ac_try) 2>&5
  2015.   ac_status=$?
  2016.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2017.   test $ac_status = 0; }; }; then :;
  2018.       else
  2019.         gmp_prog_cxx_works="no, program does not run"
  2020.       fi
  2021.     fi
  2022.   else
  2023.     gmp_prog_cxx_works="no"
  2024.   fi
  2025.   case $gmp_prog_cxx_works in
  2026.     no*)
  2027.       echo "failed program was:" >&5
  2028.       cat conftest.cc >&5
  2029.       ;;
  2030.   esac
  2031.   rm -f conftest* a.out b.out a.exe a_out.exe
  2032. fi
  2033. if test "$gmp_prog_cxx_works" = yes; then
  2034.   # remove anything that might look like compiler output to our "||" expression
  2035.   rm -f conftest* a.out b.out a.exe a_out.exe
  2036.   cat >conftest.cc <<EOF
  2037. namespace foo { }
  2038. using namespace foo;
  2039. int main (void) { return 0; }
  2040. EOF
  2041.   echo "Test compile: namespace" >&5
  2042.   gmp_cxxcompile="$CXX $CPPFLAGS $CXXFLAGS conftest.cc >&5"
  2043.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_cxxcompile""; } >&5
  2044.   (eval $gmp_cxxcompile) 2>&5
  2045.   ac_status=$?
  2046.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2047.   test $ac_status = 0; }; then
  2048.     if test "$cross_compiling" = no; then
  2049.       if { ac_try='./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest'
  2050.   { { eval echo ""$as_me":${as_lineno-$LINENO}: "$ac_try""; } >&5
  2051.   (eval $ac_try) 2>&5
  2052.   ac_status=$?
  2053.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2054.   test $ac_status = 0; }; }; then :;
  2055.       else
  2056.         gmp_prog_cxx_works="no, namespace, program does not run"
  2057.       fi
  2058.     fi
  2059.   else
  2060.     gmp_prog_cxx_works="no, namespace"
  2061.   fi
  2062.   case $gmp_prog_cxx_works in
  2063.     no*)
  2064.       echo "failed program was:" >&5
  2065.       cat conftest.cc >&5
  2066.       ;;
  2067.   esac
  2068.   rm -f conftest* a.out b.out a.exe a_out.exe
  2069. fi
  2070. # GMP requires the standard C++ iostream classes
  2071. if test "$gmp_prog_cxx_works" = yes; then
  2072.   # remove anything that might look like compiler output to our "||" expression
  2073.   rm -f conftest* a.out b.out a.exe a_out.exe
  2074.   cat >conftest.cc <<EOF
  2075. /* This test rejects g++ 2.7.2 which doesn't have <iostream>, only a
  2076.     pre-standard iostream.h. */
  2077. #include <iostream>
  2078. /* This test rejects OSF 5.1 Compaq C++ in its default pre-standard iostream
  2079.    mode, since that mode puts cout in the global namespace, not "std".  */
  2080. void someoutput (void) { std::cout << 123; }
  2081. int main (void) { return 0; }
  2082. EOF
  2083.   echo "Test compile: std iostream" >&5
  2084.   gmp_cxxcompile="$CXX $CPPFLAGS $CXXFLAGS conftest.cc >&5"
  2085.   if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_cxxcompile""; } >&5
  2086.   (eval $gmp_cxxcompile) 2>&5
  2087.   ac_status=$?
  2088.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2089.   test $ac_status = 0; }; then
  2090.     if test "$cross_compiling" = no; then
  2091.       if { ac_try='./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest'
  2092.   { { eval echo ""$as_me":${as_lineno-$LINENO}: "$ac_try""; } >&5
  2093.   (eval $ac_try) 2>&5
  2094.   ac_status=$?
  2095.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2096.   test $ac_status = 0; }; }; then :;
  2097.       else
  2098.         gmp_prog_cxx_works="no, std iostream, program does not run"
  2099.       fi
  2100.     fi
  2101.   else
  2102.     gmp_prog_cxx_works="no, std iostream"
  2103.   fi
  2104.   case $gmp_prog_cxx_works in
  2105.     no*)
  2106.       echo "failed program was:" >&5
  2107.       cat conftest.cc >&5
  2108.       ;;
  2109.   esac
  2110.   rm -f conftest* a.out b.out a.exe a_out.exe
  2111. fi
  2112. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $gmp_prog_cxx_works" >&5
  2113. $as_echo "$gmp_prog_cxx_works" >&6; }
  2114. case $gmp_prog_cxx_works in
  2115.   yes)
  2116.     want_cxx=yes
  2117.       break
  2118.     ;;
  2119.   *)
  2120.     ;;
  2121. esac
  2122.   done
  2123.   # If --enable-cxx=yes but a C++ compiler can't be found, then abort.
  2124.   if test $want_cxx = no && test $enable_cxx = yes; then
  2125.     as_fn_error "C++ compiler not available, see config.log for details" "$LINENO" 5
  2126.   fi
  2127. fi
  2128.  if test $want_cxx = yes; then
  2129.   WANT_CXX_TRUE=
  2130.   WANT_CXX_FALSE='#'
  2131. else
  2132.   WANT_CXX_TRUE='#'
  2133.   WANT_CXX_FALSE=
  2134. fi
  2135. # FIXME: We're not interested in CXXCPP for ourselves, but if we don't do it
  2136. # here then AC_PROG_LIBTOOL will AC_REQUIRE it (via _LT_AC_TAGCONFIG) and
  2137. # hence execute it unconditionally, and that will fail if there's no C++
  2138. # compiler (and no generic /lib/cpp).
  2139. #
  2140. if test $want_cxx = yes; then
  2141.   ac_ext=cpp
  2142. ac_cpp='$CXXCPP $CPPFLAGS'
  2143. ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
  2144. ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
  2145. ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
  2146. { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5
  2147. $as_echo_n "checking how to run the C++ preprocessor... " >&6; }
  2148. if test -z "$CXXCPP"; then
  2149.   if test "${ac_cv_prog_CXXCPP+set}" = set; then :
  2150.   $as_echo_n "(cached) " >&6
  2151. else
  2152.       # Double quotes because CXXCPP needs to be expanded
  2153.     for CXXCPP in "$CXX -E" "/lib/cpp"
  2154.     do
  2155.       ac_preproc_ok=false
  2156. for ac_cxx_preproc_warn_flag in '' yes
  2157. do
  2158.   # Use a header file that comes with gcc, so configuring glibc
  2159.   # with a fresh cross-compiler works.
  2160.   # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
  2161.   # <limits.h> exists even on freestanding compilers.
  2162.   # On the NeXT, cc -E runs the code through the compiler's parser,
  2163.   # not just through cpp. "Syntax error" is here to catch this case.
  2164.   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  2165. /* end confdefs.h.  */
  2166. #ifdef __STDC__
  2167. # include <limits.h>
  2168. #else
  2169. # include <assert.h>
  2170. #endif
  2171.      Syntax error
  2172. _ACEOF
  2173. if ac_fn_cxx_try_cpp "$LINENO"; then :
  2174. else
  2175.   # Broken: fails on valid input.
  2176. continue
  2177. fi
  2178. rm -f conftest.err conftest.$ac_ext
  2179.   # OK, works on sane cases.  Now check whether nonexistent headers
  2180.   # can be detected and how.
  2181.   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  2182. /* end confdefs.h.  */
  2183. #include <ac_nonexistent.h>
  2184. _ACEOF
  2185. if ac_fn_cxx_try_cpp "$LINENO"; then :
  2186.   # Broken: success on invalid input.
  2187. continue
  2188. else
  2189.   # Passes both tests.
  2190. ac_preproc_ok=:
  2191. break
  2192. fi
  2193. rm -f conftest.err conftest.$ac_ext
  2194. done
  2195. # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
  2196. rm -f conftest.err conftest.$ac_ext
  2197. if $ac_preproc_ok; then :
  2198.   break
  2199. fi
  2200.     done
  2201.     ac_cv_prog_CXXCPP=$CXXCPP
  2202. fi
  2203.   CXXCPP=$ac_cv_prog_CXXCPP
  2204. else
  2205.   ac_cv_prog_CXXCPP=$CXXCPP
  2206. fi
  2207. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5
  2208. $as_echo "$CXXCPP" >&6; }
  2209. ac_preproc_ok=false
  2210. for ac_cxx_preproc_warn_flag in '' yes
  2211. do
  2212.   # Use a header file that comes with gcc, so configuring glibc
  2213.   # with a fresh cross-compiler works.
  2214.   # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
  2215.   # <limits.h> exists even on freestanding compilers.
  2216.   # On the NeXT, cc -E runs the code through the compiler's parser,
  2217.   # not just through cpp. "Syntax error" is here to catch this case.
  2218.   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  2219. /* end confdefs.h.  */
  2220. #ifdef __STDC__
  2221. # include <limits.h>
  2222. #else
  2223. # include <assert.h>
  2224. #endif
  2225.      Syntax error
  2226. _ACEOF
  2227. if ac_fn_cxx_try_cpp "$LINENO"; then :
  2228. else
  2229.   # Broken: fails on valid input.
  2230. continue
  2231. fi
  2232. rm -f conftest.err conftest.$ac_ext
  2233.   # OK, works on sane cases.  Now check whether nonexistent headers
  2234.   # can be detected and how.
  2235.   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  2236. /* end confdefs.h.  */
  2237. #include <ac_nonexistent.h>
  2238. _ACEOF
  2239. if ac_fn_cxx_try_cpp "$LINENO"; then :
  2240.   # Broken: success on invalid input.
  2241. continue
  2242. else
  2243.   # Passes both tests.
  2244. ac_preproc_ok=:
  2245. break
  2246. fi
  2247. rm -f conftest.err conftest.$ac_ext
  2248. done
  2249. # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
  2250. rm -f conftest.err conftest.$ac_ext
  2251. if $ac_preproc_ok; then :
  2252. else
  2253.   { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in `$ac_pwd':" >&5
  2254. $as_echo "$as_me: error: in `$ac_pwd':" >&2;}
  2255. as_fn_error "C++ preprocessor "$CXXCPP" fails sanity check
  2256. See `config.log' for more details." "$LINENO" 5; }
  2257. fi
  2258. ac_ext=c
  2259. ac_cpp='$CPP $CPPFLAGS'
  2260. ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
  2261. ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
  2262. ac_compiler_gnu=$ac_cv_c_compiler_gnu
  2263. fi
  2264. # Path setups for Cray, according to IEEE or CFP.  These must come after
  2265. # deciding the compiler.
  2266. #
  2267. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
  2268. $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
  2269. if test "${ac_cv_path_GREP+set}" = set; then :
  2270.   $as_echo_n "(cached) " >&6
  2271. else
  2272.   if test -z "$GREP"; then
  2273.   ac_path_GREP_found=false
  2274.   # Loop through the user's path and test for each of PROGNAME-LIST
  2275.   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
  2276. for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
  2277. do
  2278.   IFS=$as_save_IFS
  2279.   test -z "$as_dir" && as_dir=.
  2280.     for ac_prog in grep ggrep; do
  2281.     for ac_exec_ext in '' $ac_executable_extensions; do
  2282.       ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
  2283.       { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue
  2284. # Check for GNU ac_path_GREP and select it if it is found.
  2285.   # Check for GNU $ac_path_GREP
  2286. case `"$ac_path_GREP" --version 2>&1` in
  2287. *GNU*)
  2288.   ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
  2289. *)
  2290.   ac_count=0
  2291.   $as_echo_n 0123456789 >"conftest.in"
  2292.   while :
  2293.   do
  2294.     cat "conftest.in" "conftest.in" >"conftest.tmp"
  2295.     mv "conftest.tmp" "conftest.in"
  2296.     cp "conftest.in" "conftest.nl"
  2297.     $as_echo 'GREP' >> "conftest.nl"
  2298.     "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
  2299.     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
  2300.     as_fn_arith $ac_count + 1 && ac_count=$as_val
  2301.     if test $ac_count -gt ${ac_path_GREP_max-0}; then
  2302.       # Best one so far, save it but keep looking for a better one
  2303.       ac_cv_path_GREP="$ac_path_GREP"
  2304.       ac_path_GREP_max=$ac_count
  2305.     fi
  2306.     # 10*(2^10) chars as input seems more than enough
  2307.     test $ac_count -gt 10 && break
  2308.   done
  2309.   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
  2310. esac
  2311.       $ac_path_GREP_found && break 3
  2312.     done
  2313.   done
  2314.   done
  2315. IFS=$as_save_IFS
  2316.   if test -z "$ac_cv_path_GREP"; then
  2317.     as_fn_error "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
  2318.   fi
  2319. else
  2320.   ac_cv_path_GREP=$GREP
  2321. fi
  2322. fi
  2323. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
  2324. $as_echo "$ac_cv_path_GREP" >&6; }
  2325.  GREP="$ac_cv_path_GREP"
  2326. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
  2327. $as_echo_n "checking for egrep... " >&6; }
  2328. if test "${ac_cv_path_EGREP+set}" = set; then :
  2329.   $as_echo_n "(cached) " >&6
  2330. else
  2331.   if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
  2332.    then ac_cv_path_EGREP="$GREP -E"
  2333.    else
  2334.      if test -z "$EGREP"; then
  2335.   ac_path_EGREP_found=false
  2336.   # Loop through the user's path and test for each of PROGNAME-LIST
  2337.   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
  2338. for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
  2339. do
  2340.   IFS=$as_save_IFS
  2341.   test -z "$as_dir" && as_dir=.
  2342.     for ac_prog in egrep; do
  2343.     for ac_exec_ext in '' $ac_executable_extensions; do
  2344.       ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
  2345.       { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue
  2346. # Check for GNU ac_path_EGREP and select it if it is found.
  2347.   # Check for GNU $ac_path_EGREP
  2348. case `"$ac_path_EGREP" --version 2>&1` in
  2349. *GNU*)
  2350.   ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
  2351. *)
  2352.   ac_count=0
  2353.   $as_echo_n 0123456789 >"conftest.in"
  2354.   while :
  2355.   do
  2356.     cat "conftest.in" "conftest.in" >"conftest.tmp"
  2357.     mv "conftest.tmp" "conftest.in"
  2358.     cp "conftest.in" "conftest.nl"
  2359.     $as_echo 'EGREP' >> "conftest.nl"
  2360.     "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
  2361.     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
  2362.     as_fn_arith $ac_count + 1 && ac_count=$as_val
  2363.     if test $ac_count -gt ${ac_path_EGREP_max-0}; then
  2364.       # Best one so far, save it but keep looking for a better one
  2365.       ac_cv_path_EGREP="$ac_path_EGREP"
  2366.       ac_path_EGREP_max=$ac_count
  2367.     fi
  2368.     # 10*(2^10) chars as input seems more than enough
  2369.     test $ac_count -gt 10 && break
  2370.   done
  2371.   rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
  2372. esac
  2373.       $ac_path_EGREP_found && break 3
  2374.     done
  2375.   done
  2376.   done
  2377. IFS=$as_save_IFS
  2378.   if test -z "$ac_cv_path_EGREP"; then
  2379.     as_fn_error "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
  2380.   fi
  2381. else
  2382.   ac_cv_path_EGREP=$EGREP
  2383. fi
  2384.    fi
  2385. fi
  2386. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
  2387. $as_echo "$ac_cv_path_EGREP" >&6; }
  2388.  EGREP="$ac_cv_path_EGREP"
  2389. case $host_cpu in
  2390.   c90 | t90)
  2391.     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  2392. /* end confdefs.h.  */
  2393. #ifdef _CRAYIEEE
  2394. yes
  2395. #endif
  2396. _ACEOF
  2397. if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
  2398.   $EGREP "yes" >/dev/null 2>&1; then :
  2399.   add_path="cray/ieee"
  2400. else
  2401.   add_path="cray/cfp"; extra_functions="mulwwc90"
  2402. fi
  2403. rm -f conftest*
  2404.     ;;
  2405.   j90 | sv1)
  2406.     add_path="cray/cfp"; extra_functions="mulwwj90"
  2407.     ;;
  2408. esac
  2409. if test -z "$MPN_PATH"; then
  2410.   path="$add_path $path"
  2411. fi
  2412. # For a nail build, also look in "nails" subdirectories.
  2413. #
  2414. if test $GMP_NAIL_BITS != 0 && test -z "$MPN_PATH"; then
  2415.   new_path=
  2416.   for i in $path; do
  2417.     case $i in
  2418.     generic) new_path="$new_path $i" ;;
  2419.     *)       new_path="$new_path $i/nails $i" ;;
  2420.     esac
  2421.   done
  2422.   path=$new_path
  2423. fi
  2424. # Put all directories into CPUVEC_list so as to get a full set of
  2425. # CPUVEC_SETUP_$tmp_suffix defines into config.h, even if some of them are
  2426. # empty because mmx and/or sse2 had to be dropped.
  2427. #
  2428. for i in $fat_path; do
  2429.   tmp_suffix=`echo $i | sed -e '///s:^[^/]*/::' -e 's:[\/]:_:g'`
  2430.   CPUVEC_list="$CPUVEC_list CPUVEC_SETUP_$tmp_suffix"
  2431. done
  2432. # If there's any sse2 or mmx in the path, check whether the assembler
  2433. # supports it, and remove if not.
  2434. #
  2435. # We only need this in ABI=32, for ABI=64 on x86_64 we can assume a new
  2436. # enough assembler.
  2437. #
  2438. case $host in
  2439.   i?86*-*-* | k[5-8]*-*-* | pentium*-*-* | athlon-*-* | viac3*-*-* | geode*-*-* | atom-*-* | athlon64-*-* | pentium4-*-* | atom-*-* | core2-*-* | corei-*-* | x86_64-*-* | nano-*-*)
  2440.     if test "$ABI" = 32; then
  2441.       case "$path $fat_path" in
  2442.         *mmx*)   { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the assembler knows about MMX instructions" >&5
  2443. $as_echo_n "checking if the assembler knows about MMX instructions... " >&6; }
  2444. if test "${gmp_cv_asm_x86_mmx+set}" = set; then :
  2445.   $as_echo_n "(cached) " >&6
  2446. else
  2447.   cat >conftest.s <<EOF
  2448. .text
  2449. movq %mm0, %mm1
  2450. EOF
  2451. gmp_assemble="$CCAS $CFLAGS $CPPFLAGS conftest.s >conftest.out 2>&1"
  2452. if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_assemble""; } >&5
  2453.   (eval $gmp_assemble) 2>&5
  2454.   ac_status=$?
  2455.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2456.   test $ac_status = 0; }; then
  2457.   cat conftest.out >&5
  2458.   gmp_cv_asm_x86_mmx=yes
  2459. case $host in
  2460. *-*-solaris*)
  2461.   if (dis conftest.$OBJEXT >conftest.out) 2>/dev/null; then
  2462.     if grep "0f 6f c1" conftest.out >/dev/null; then
  2463.       gmp_cv_asm_x86_mmx=movq-bug
  2464.     fi
  2465.   else
  2466.     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: "dis" not available to check for "as" movq bug" >&5
  2467. $as_echo "$as_me: WARNING: "dis" not available to check for "as" movq bug" >&2;}
  2468.   fi
  2469. esac
  2470. else
  2471.   cat conftest.out >&5
  2472.   echo "configure: failed program was:" >&5
  2473.   cat conftest.s >&5
  2474.   gmp_cv_asm_x86_mmx=no
  2475. fi
  2476. rm -f conftest*
  2477. fi
  2478. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $gmp_cv_asm_x86_mmx" >&5
  2479. $as_echo "$gmp_cv_asm_x86_mmx" >&6; }
  2480. case $gmp_cv_asm_x86_mmx in
  2481. movq-bug)
  2482.   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: +----------------------------------------------------------" >&5
  2483. $as_echo "$as_me: WARNING: +----------------------------------------------------------" >&2;}
  2484.   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: | WARNING WARNING WARNING" >&5
  2485. $as_echo "$as_me: WARNING: | WARNING WARNING WARNING" >&2;}
  2486.   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: | Host CPU has MMX code, but the assembler" >&5
  2487. $as_echo "$as_me: WARNING: | Host CPU has MMX code, but the assembler" >&2;}
  2488.   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: |     $CCAS $CFLAGS $CPPFLAGS" >&5
  2489. $as_echo "$as_me: WARNING: |     $CCAS $CFLAGS $CPPFLAGS" >&2;}
  2490.   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: | has the Solaris 2.6 and 2.7 bug where register to register" >&5
  2491. $as_echo "$as_me: WARNING: | has the Solaris 2.6 and 2.7 bug where register to register" >&2;}
  2492.   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: | movq operands are reversed." >&5
  2493. $as_echo "$as_me: WARNING: | movq operands are reversed." >&2;}
  2494.   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: | Non-MMX replacements will be used." >&5
  2495. $as_echo "$as_me: WARNING: | Non-MMX replacements will be used." >&2;}
  2496.   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: | This will be an inferior build." >&5
  2497. $as_echo "$as_me: WARNING: | This will be an inferior build." >&2;}
  2498.   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: +----------------------------------------------------------" >&5
  2499. $as_echo "$as_me: WARNING: +----------------------------------------------------------" >&2;}
  2500.   ;;
  2501. no)
  2502.   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: +----------------------------------------------------------" >&5
  2503. $as_echo "$as_me: WARNING: +----------------------------------------------------------" >&2;}
  2504.   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: | WARNING WARNING WARNING" >&5
  2505. $as_echo "$as_me: WARNING: | WARNING WARNING WARNING" >&2;}
  2506.   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: | Host CPU has MMX code, but it can't be assembled by" >&5
  2507. $as_echo "$as_me: WARNING: | Host CPU has MMX code, but it can't be assembled by" >&2;}
  2508.   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: |     $CCAS $CFLAGS $CPPFLAGS" >&5
  2509. $as_echo "$as_me: WARNING: |     $CCAS $CFLAGS $CPPFLAGS" >&2;}
  2510.   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: | Non-MMX replacements will be used." >&5
  2511. $as_echo "$as_me: WARNING: | Non-MMX replacements will be used." >&2;}
  2512.   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: | This will be an inferior build." >&5
  2513. $as_echo "$as_me: WARNING: | This will be an inferior build." >&2;}
  2514.   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: +----------------------------------------------------------" >&5
  2515. $as_echo "$as_me: WARNING: +----------------------------------------------------------" >&2;}
  2516.   ;;
  2517. esac
  2518. if test "$gmp_cv_asm_x86_mmx" = yes; then
  2519.   :
  2520. else
  2521.   tmp_path=
  2522. for i in $path; do
  2523.   case $i in
  2524.     */*mmx*) ;;
  2525.     *) tmp_path="$tmp_path $i" ;;
  2526.   esac
  2527. done
  2528. path="$tmp_path"
  2529. tmp_path=
  2530. for i in $fat_path; do
  2531.   case $i in
  2532.     */*mmx*) ;;
  2533.     *) tmp_path="$tmp_path $i" ;;
  2534.   esac
  2535. done
  2536. fat_path="$tmp_path"
  2537. fi
  2538.  ;;
  2539.       esac
  2540.       case "$path $fat_path" in
  2541.         *sse2*)  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the assembler knows about SSE2 instructions" >&5
  2542. $as_echo_n "checking if the assembler knows about SSE2 instructions... " >&6; }
  2543. if test "${gmp_cv_asm_x86_sse2+set}" = set; then :
  2544.   $as_echo_n "(cached) " >&6
  2545. else
  2546.   cat >conftest.s <<EOF
  2547. .text
  2548. paddq %mm0, %mm1
  2549. EOF
  2550. gmp_assemble="$CCAS $CFLAGS $CPPFLAGS conftest.s >conftest.out 2>&1"
  2551. if { { eval echo ""$as_me":${as_lineno-$LINENO}: "$gmp_assemble""; } >&5
  2552.   (eval $gmp_assemble) 2>&5
  2553.   ac_status=$?
  2554.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2555.   test $ac_status = 0; }; then
  2556.   cat conftest.out >&5
  2557.   gmp_cv_asm_x86_sse2=yes
  2558. else
  2559.   cat conftest.out >&5
  2560.   echo "configure: failed program was:" >&5
  2561.   cat conftest.s >&5
  2562.   gmp_cv_asm_x86_sse2=no
  2563. fi
  2564. rm -f conftest*
  2565. fi
  2566. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $gmp_cv_asm_x86_sse2" >&5
  2567. $as_echo "$gmp_cv_asm_x86_sse2" >&6; }
  2568. case $gmp_cv_asm_x86_sse2 in
  2569. yes)
  2570.   :
  2571.   ;;
  2572. *)
  2573.   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: +----------------------------------------------------------" >&5
  2574. $as_echo "$as_me: WARNING: +----------------------------------------------------------" >&2;}
  2575.   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: | WARNING WARNING WARNING" >&5
  2576. $as_echo "$as_me: WARNING: | WARNING WARNING WARNING" >&2;}
  2577.   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: | Host CPU has SSE2 code, but it can't be assembled by" >&5
  2578. $as_echo "$as_me: WARNING: | Host CPU has SSE2 code, but it can't be assembled by" >&2;}
  2579.   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: |     $CCAS $CFLAGS $CPPFLAGS" >&5
  2580. $as_echo "$as_me: WARNING: |     $CCAS $CFLAGS $CPPFLAGS" >&2;}
  2581.   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: | Non-SSE2 replacements will be used." >&5
  2582. $as_echo "$as_me: WARNING: | Non-SSE2 replacements will be used." >&2;}
  2583.   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: | This will be an inferior build." >&5
  2584. $as_echo "$as_me: WARNING: | This will be an inferior build." >&2;}
  2585.   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: +----------------------------------------------------------" >&5
  2586. $as_echo "$as_me: WARNING: +----------------------------------------------------------" >&2;}
  2587.   tmp_path=
  2588. for i in $path; do
  2589.   case $i in
  2590.     */sse2) ;;
  2591.     *) tmp_path="$tmp_path $i" ;;
  2592.   esac
  2593. done
  2594. path="$tmp_path"
  2595. tmp_path=
  2596. for i in $fat_path; do
  2597.   case $i in
  2598.     */sse2) ;;
  2599.     *) tmp_path="$tmp_path $i" ;;
  2600.   esac
  2601. done
  2602. fat_path="$tmp_path"
  2603.   ;;
  2604. esac
  2605.  ;;
  2606.       esac
  2607.     fi
  2608.     ;;
  2609. esac
  2610. cat >&5 <<EOF
  2611. Decided:
  2612. ABI=$ABI
  2613. CC=$CC
  2614. CFLAGS=$CFLAGS
  2615. CPPFLAGS=$CPPFLAGS
  2616. GMP_LDFLAGS=$GMP_LDFLAGS
  2617. CXX=$CXX
  2618. CXXFLAGS=$CXXFLAGS
  2619. path=$path
  2620. EOF
  2621. echo "using ABI="$ABI""
  2622. echo "      CC="$CC""
  2623. echo "      CFLAGS="$CFLAGS""
  2624. echo "      CPPFLAGS="$CPPFLAGS""
  2625. if test $want_cxx = yes; then
  2626.   echo "      CXX="$CXX""
  2627.   echo "      CXXFLAGS="$CXXFLAGS""
  2628. fi
  2629. echo "      MPN_PATH="$path""
  2630. # Automake ansi2knr support.
  2631. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for function prototypes" >&5
  2632. $as_echo_n "checking for function prototypes... " >&6; }
  2633. if test "$ac_cv_prog_cc_c89" != no; then
  2634.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
  2635. $as_echo "yes" >&6; }
  2636. $as_echo "#define PROTOTYPES 1" >>confdefs.h
  2637. $as_echo "#define __PROTOTYPES 1" >>confdefs.h
  2638. else
  2639.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  2640. $as_echo "no" >&6; }
  2641. fi
  2642. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
  2643. $as_echo_n "checking for ANSI C header files... " >&6; }
  2644. if test "${ac_cv_header_stdc+set}" = set; then :
  2645.   $as_echo_n "(cached) " >&6
  2646. else
  2647.   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  2648. /* end confdefs.h.  */
  2649. #include <stdlib.h>
  2650. #include <stdarg.h>
  2651. #include <string.h>
  2652. #include <float.h>
  2653. int
  2654. main ()
  2655. {
  2656.   ;
  2657.   return 0;
  2658. }
  2659. _ACEOF
  2660. if ac_fn_c_try_compile "$LINENO"; then :
  2661.   ac_cv_header_stdc=yes
  2662. else
  2663.   ac_cv_header_stdc=no
  2664. fi
  2665. rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  2666. if test $ac_cv_header_stdc = yes; then
  2667.   # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
  2668.   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  2669. /* end confdefs.h.  */
  2670. #include <string.h>
  2671. _ACEOF
  2672. if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
  2673.   $EGREP "memchr" >/dev/null 2>&1; then :
  2674. else
  2675.   ac_cv_header_stdc=no
  2676. fi
  2677. rm -f conftest*
  2678. fi
  2679. if test $ac_cv_header_stdc = yes; then
  2680.   # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
  2681.   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  2682. /* end confdefs.h.  */
  2683. #include <stdlib.h>
  2684. _ACEOF
  2685. if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
  2686.   $EGREP "free" >/dev/null 2>&1; then :
  2687. else
  2688.   ac_cv_header_stdc=no
  2689. fi
  2690. rm -f conftest*
  2691. fi
  2692. if test $ac_cv_header_stdc = yes; then
  2693.   # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
  2694.   if test "$cross_compiling" = yes; then :
  2695.   :
  2696. else
  2697.   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
  2698. /* end confdefs.h.  */
  2699. #include <ctype.h>
  2700. #include <stdlib.h>
  2701. #if ((' ' & 0x0FF) == 0x020)
  2702. # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
  2703. # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
  2704. #else
  2705. # define ISLOWER(c) 
  2706.    (('a' <= (c) && (c) <= 'i') 
  2707.      || ('j' <= (c) && (c) <= 'r') 
  2708.      || ('s' <= (c) && (c) <= 'z'))
  2709. # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
  2710. #endif
  2711. #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
  2712. int
  2713. main ()
  2714. {
  2715.   int i;
  2716.   for (i = 0; i < 256; i++)
  2717.     if (XOR (islower (i), ISLOWER (i))
  2718. || toupper (i) != TOUPPER (i))
  2719.       return 2;
  2720.   return 0;
  2721. }
  2722. _ACEOF
  2723. if ac_fn_c_try_run "$LINENO"; then :
  2724. else
  2725.   ac_cv_header_stdc=no
  2726. fi
  2727. rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext 
  2728.   conftest.$ac_objext conftest.beam conftest.$ac_ext
  2729. fi
  2730. fi
  2731. fi
  2732. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
  2733. $as_echo "$ac_cv_header_stdc" >&6; }
  2734. if test $ac_cv_header_stdc = yes; then
  2735. $as_echo "#define STDC_HEADERS 1" >>confdefs.h
  2736. fi
  2737. # On IRIX 5.3, sys/types and inttypes.h are conflicting.
  2738. for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h 
  2739.   inttypes.h stdint.h unistd.h
  2740. do :
  2741.   as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
  2742. ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default
  2743. "
  2744. eval as_val=$$as_ac_Header
  2745.    if test "x$as_val" = x""yes; then :
  2746.   cat >>confdefs.h <<_ACEOF
  2747. #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
  2748. _ACEOF
  2749. fi
  2750. done
  2751. if test "$ac_cv_prog_cc_stdc" != no; then
  2752.   U= ANSI2KNR=
  2753. else
  2754.   U=_ ANSI2KNR=./ansi2knr
  2755. fi
  2756. # Ensure some checks needed by ansi2knr itself.
  2757. for ac_header in string.h
  2758. do :
  2759.   ac_fn_c_check_header_mongrel "$LINENO" "string.h" "ac_cv_header_string_h" "$ac_includes_default"
  2760. if test "x$ac_cv_header_string_h" = x""yes; then :
  2761.   cat >>confdefs.h <<_ACEOF
  2762. #define HAVE_STRING_H 1
  2763. _ACEOF
  2764. fi
  2765. done
  2766. { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether assembler supports --noexecstack option" >&5
  2767. $as_echo_n "checking whether assembler supports --noexecstack option... " >&6; }
  2768. if test "${cl_cv_as_noexecstack+set}" = set; then :
  2769.   $as_echo_n "(cached) " >&6
  2770. else
  2771.     cat > conftest.c <<EOF
  2772. void foo() {}
  2773. EOF
  2774.   if { ac_try='${CC} $CFLAGS $CPPFLAGS
  2775.                      -S -o conftest.s conftest.c >/dev/null'
  2776.   { { eval echo ""$as_me":${as_lineno-$LINENO}: "$ac_try""; } >&5
  2777.   (eval $ac_try) 2>&5
  2778.   ac_status=$?
  2779.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2780.   test $ac_status = 0; }; } 
  2781.      && grep .note.GNU-stack conftest.s >/dev/null 
  2782.      && { ac_try='${CC} $CFLAGS $CPPFLAGS -Wa,--noexecstack
  2783.                        -c -o conftest.o conftest.s >/dev/null'
  2784.   { { eval echo ""$as_me":${as_lineno-$LINENO}: "$ac_try""; } >&5
  2785.   (eval $ac_try) 2>&5
  2786.   ac_status=$?
  2787.   $as_echo "$as_me:${as_lineno-$LINENO}: $? = $ac_status" >&5
  2788.   test $ac_status = 0; }; }
  2789.   then
  2790.     cl_cv_as_noexecstack=yes
  2791.   else
  2792.     cl_cv_as_noexecstack=no
  2793.   fi
  2794.   rm -f conftest*
  2795. fi
  2796. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $cl_cv_as_noexecstack" >&5
  2797. $as_echo "$cl_cv_as_noexecstack" >&6; }
  2798.   if test "$cl_cv_as_noexecstack" = yes; then
  2799.     ASMFLAGS="$ASMFLAGS -Wa,--noexecstack"
  2800.   fi
  2801. gmp_user_AR=$AR
  2802. if test -n "$ac_tool_prefix"; then
  2803.   # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
  2804. set dummy ${ac_tool_prefix}ar; ac_word=$2
  2805. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
  2806. $as_echo_n "checking for $ac_word... " >&6; }
  2807. if test "${ac_cv_prog_AR+set}" = set; then :
  2808.   $as_echo_n "(cached) " >&6
  2809. else
  2810.   if test -n "$AR"; then
  2811.   ac_cv_prog_AR="$AR" # Let the user override the test.
  2812. else
  2813. as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
  2814. for as_dir in $PATH
  2815. do
  2816.   IFS=$as_save_IFS
  2817.   test -z "$as_dir" && as_dir=.
  2818.     for ac_exec_ext in '' $ac_executable_extensions; do
  2819.   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
  2820.     ac_cv_prog_AR="${ac_tool_prefix}ar"
  2821.     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
  2822.     break 2
  2823.   fi
  2824. done
  2825.   done
  2826. IFS=$as_save_IFS
  2827. fi
  2828. fi
  2829. AR=$ac_cv_prog_AR
  2830. if test -n "$AR"; then
  2831.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
  2832. $as_echo "$AR" >&6; }
  2833. else
  2834.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  2835. $as_echo "no" >&6; }
  2836. fi
  2837. fi
  2838. if test -z "$ac_cv_prog_AR"; then
  2839.   ac_ct_AR=$AR
  2840.   # Extract the first word of "ar", so it can be a program name with args.
  2841. set dummy ar; ac_word=$2
  2842. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
  2843. $as_echo_n "checking for $ac_word... " >&6; }
  2844. if test "${ac_cv_prog_ac_ct_AR+set}" = set; then :
  2845.   $as_echo_n "(cached) " >&6
  2846. else
  2847.   if test -n "$ac_ct_AR"; then
  2848.   ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
  2849. else
  2850. as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
  2851. for as_dir in $PATH
  2852. do
  2853.   IFS=$as_save_IFS
  2854.   test -z "$as_dir" && as_dir=.
  2855.     for ac_exec_ext in '' $ac_executable_extensions; do
  2856.   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
  2857.     ac_cv_prog_ac_ct_AR="ar"
  2858.     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
  2859.     break 2
  2860.   fi
  2861. done
  2862.   done
  2863. IFS=$as_save_IFS
  2864. fi
  2865. fi
  2866. ac_ct_AR=$ac_cv_prog_ac_ct_AR
  2867. if test -n "$ac_ct_AR"; then
  2868.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
  2869. $as_echo "$ac_ct_AR" >&6; }
  2870. else
  2871.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  2872. $as_echo "no" >&6; }
  2873. fi
  2874.   if test "x$ac_ct_AR" = x; then
  2875.     AR="ar"
  2876.   else
  2877.     case $cross_compiling:$ac_tool_warned in
  2878. yes:)
  2879. { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
  2880. $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
  2881. ac_tool_warned=yes ;;
  2882. esac
  2883.     AR=$ac_ct_AR
  2884.   fi
  2885. else
  2886.   AR="$ac_cv_prog_AR"
  2887. fi
  2888. if test -z "$gmp_user_AR"; then
  2889.                         eval arflags="$ar${abi1}_flags"
  2890.   test -n "$arflags" || eval arflags="$ar${abi2}_flags"
  2891.   if test -n "$arflags"; then
  2892.     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for extra ar flags" >&5
  2893. $as_echo_n "checking for extra ar flags... " >&6; }
  2894.     AR="$AR $arflags"
  2895.     ac_cv_prog_AR="$AR $arflags"
  2896.     ac_cv_prog_ac_ct_AR="$AR $arflags"
  2897.     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $arflags" >&5
  2898. $as_echo "$arflags" >&6; }
  2899.   fi
  2900. fi
  2901. if test -z "$AR_FLAGS"; then
  2902.   AR_FLAGS=cq
  2903. fi
  2904. gmp_user_NM=$NM
  2905. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BSD- or MS-compatible name lister (nm)" >&5
  2906. $as_echo_n "checking for BSD- or MS-compatible name lister (nm)... " >&6; }
  2907. if test "${lt_cv_path_NM+set}" = set; then :
  2908.   $as_echo_n "(cached) " >&6
  2909. else
  2910.   if test -n "$NM"; then
  2911.   # Let the user override the test.
  2912.   lt_cv_path_NM="$NM"
  2913. else
  2914.   lt_nm_to_check="${ac_tool_prefix}nm"
  2915.   if test -n "$ac_tool_prefix" && test "$build" = "$host"; then
  2916.     lt_nm_to_check="$lt_nm_to_check nm"
  2917.   fi
  2918.   for lt_tmp_nm in $lt_nm_to_check; do
  2919.     lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
  2920.     for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do
  2921.       IFS="$lt_save_ifs"
  2922.       test -z "$ac_dir" && ac_dir=.
  2923.       tmp_nm="$ac_dir/$lt_tmp_nm"
  2924.       if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then
  2925. # Check to see if the nm accepts a BSD-compat flag.
  2926. # Adding the `sed 1q' prevents false positives on HP-UX, which says:
  2927. #   nm: unknown option "B" ignored
  2928. # Tru64's nm complains that /dev/null is an invalid object file
  2929. case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in
  2930. */dev/null* | *'Invalid file or object type'*)
  2931.   lt_cv_path_NM="$tmp_nm -B"
  2932.   break
  2933.   ;;
  2934. *)
  2935.   case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in
  2936.   */dev/null*)
  2937.     lt_cv_path_NM="$tmp_nm -p"
  2938.     break
  2939.     ;;
  2940.   *)
  2941.     lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
  2942.     continue # so that we can try to find one that supports BSD flags
  2943.     ;;
  2944.   esac
  2945.   ;;
  2946. esac
  2947.       fi
  2948.     done
  2949.     IFS="$lt_save_ifs"
  2950.   done
  2951.   : ${lt_cv_path_NM=no}
  2952. fi
  2953. fi
  2954. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_NM" >&5
  2955. $as_echo "$lt_cv_path_NM" >&6; }
  2956. if test "$lt_cv_path_NM" != "no"; then
  2957.   NM="$lt_cv_path_NM"
  2958. else
  2959.   # Didn't find any BSD compatible name lister, look for dumpbin.
  2960.   if test -n "$ac_tool_prefix"; then
  2961.   for ac_prog in "dumpbin -symbols" "link -dump -symbols"
  2962.   do
  2963.     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
  2964. set dummy $ac_tool_prefix$ac_prog; ac_word=$2
  2965. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
  2966. $as_echo_n "checking for $ac_word... " >&6; }
  2967. if test "${ac_cv_prog_DUMPBIN+set}" = set; then :
  2968.   $as_echo_n "(cached) " >&6
  2969. else
  2970.   if test -n "$DUMPBIN"; then
  2971.   ac_cv_prog_DUMPBIN="$DUMPBIN" # Let the user override the test.
  2972. else
  2973. as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
  2974. for as_dir in $PATH
  2975. do
  2976.   IFS=$as_save_IFS
  2977.   test -z "$as_dir" && as_dir=.
  2978.     for ac_exec_ext in '' $ac_executable_extensions; do
  2979.   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
  2980.     ac_cv_prog_DUMPBIN="$ac_tool_prefix$ac_prog"
  2981.     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
  2982.     break 2
  2983.   fi
  2984. done
  2985.   done
  2986. IFS=$as_save_IFS
  2987. fi
  2988. fi
  2989. DUMPBIN=$ac_cv_prog_DUMPBIN
  2990. if test -n "$DUMPBIN"; then
  2991.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DUMPBIN" >&5
  2992. $as_echo "$DUMPBIN" >&6; }
  2993. else
  2994.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  2995. $as_echo "no" >&6; }
  2996. fi
  2997.     test -n "$DUMPBIN" && break
  2998.   done
  2999. fi
  3000. if test -z "$DUMPBIN"; then
  3001.   ac_ct_DUMPBIN=$DUMPBIN
  3002.   for ac_prog in "dumpbin -symbols" "link -dump -symbols"
  3003. do
  3004.   # Extract the first word of "$ac_prog", so it can be a program name with args.
  3005. set dummy $ac_prog; ac_word=$2
  3006. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
  3007. $as_echo_n "checking for $ac_word... " >&6; }
  3008. if test "${ac_cv_prog_ac_ct_DUMPBIN+set}" = set; then :
  3009.   $as_echo_n "(cached) " >&6
  3010. else
  3011.   if test -n "$ac_ct_DUMPBIN"; then
  3012.   ac_cv_prog_ac_ct_DUMPBIN="$ac_ct_DUMPBIN" # Let the user override the test.
  3013. else
  3014. as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
  3015. for as_dir in $PATH
  3016. do
  3017.   IFS=$as_save_IFS
  3018.   test -z "$as_dir" && as_dir=.
  3019.     for ac_exec_ext in '' $ac_executable_extensions; do
  3020.   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
  3021.     ac_cv_prog_ac_ct_DUMPBIN="$ac_prog"
  3022.     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
  3023.     break 2
  3024.   fi
  3025. done
  3026.   done
  3027. IFS=$as_save_IFS
  3028. fi
  3029. fi
  3030. ac_ct_DUMPBIN=$ac_cv_prog_ac_ct_DUMPBIN
  3031. if test -n "$ac_ct_DUMPBIN"; then
  3032.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DUMPBIN" >&5
  3033. $as_echo "$ac_ct_DUMPBIN" >&6; }
  3034. else
  3035.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  3036. $as_echo "no" >&6; }
  3037. fi
  3038.   test -n "$ac_ct_DUMPBIN" && break
  3039. done
  3040.   if test "x$ac_ct_DUMPBIN" = x; then
  3041.     DUMPBIN=":"
  3042.   else
  3043.     case $cross_compiling:$ac_tool_warned in
  3044. yes:)
  3045. { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
  3046. $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
  3047. ac_tool_warned=yes ;;
  3048. esac
  3049.     DUMPBIN=$ac_ct_DUMPBIN
  3050.   fi
  3051. fi
  3052.   if test "$DUMPBIN" != ":"; then
  3053.     NM="$DUMPBIN"
  3054.   fi
  3055. fi
  3056. test -z "$NM" && NM=nm
  3057. { $as_echo "$as_me:${as_lineno-$LINENO}: checking the name lister ($NM) interface" >&5
  3058. $as_echo_n "checking the name lister ($NM) interface... " >&6; }
  3059. if test "${lt_cv_nm_interface+set}" = set; then :
  3060.   $as_echo_n "(cached) " >&6
  3061. else
  3062.   lt_cv_nm_interface="BSD nm"
  3063.   echo "int some_variable = 0;" > conftest.$ac_ext
  3064.   (eval echo ""$as_me:11213: $ac_compile"" >&5)
  3065.   (eval "$ac_compile" 2>conftest.err)
  3066.   cat conftest.err >&5
  3067.   (eval echo ""$as_me:11216: $NM \"conftest.$ac_objext\""" >&5)
  3068.   (eval "$NM "conftest.$ac_objext"" 2>conftest.err > conftest.out)
  3069.   cat conftest.err >&5
  3070.   (eval echo ""$as_me:11219: output"" >&5)
  3071.   cat conftest.out >&5
  3072.   if $GREP 'External.*some_variable' conftest.out > /dev/null; then
  3073.     lt_cv_nm_interface="MS dumpbin"
  3074.   fi
  3075.   rm -f conftest*
  3076. fi
  3077. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_nm_interface" >&5
  3078. $as_echo "$lt_cv_nm_interface" >&6; }
  3079. # FIXME: When cross compiling (ie. $ac_tool_prefix not empty), libtool
  3080. # defaults to plain "nm" if a "${ac_tool_prefix}nm" is not found.  In this
  3081. # case run it again to try the native "nm", firstly so that likely locations
  3082. # are searched, secondly so that -B or -p are added if necessary for BSD
  3083. # format.  This is necessary for instance on OSF with "./configure
  3084. # --build=alphaev5-dec-osf --host=alphaev6-dec-osf".
  3085. #
  3086. if test -z "$gmp_user_NM" && test -n "$ac_tool_prefix" && test "$NM" = nm; then
  3087.   $as_unset lt_cv_path_NM
  3088.   gmp_save_ac_tool_prefix=$ac_tool_prefix
  3089.   ac_tool_prefix=
  3090.   NM=
  3091.   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BSD- or MS-compatible name lister (nm)" >&5
  3092. $as_echo_n "checking for BSD- or MS-compatible name lister (nm)... " >&6; }
  3093. if test "${lt_cv_path_NM+set}" = set; then :
  3094.   $as_echo_n "(cached) " >&6
  3095. else
  3096.   if test -n "$NM"; then
  3097.   # Let the user override the test.
  3098.   lt_cv_path_NM="$NM"
  3099. else
  3100.   lt_nm_to_check="${ac_tool_prefix}nm"
  3101.   if test -n "$ac_tool_prefix" && test "$build" = "$host"; then
  3102.     lt_nm_to_check="$lt_nm_to_check nm"
  3103.   fi
  3104.   for lt_tmp_nm in $lt_nm_to_check; do
  3105.     lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
  3106.     for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do
  3107.       IFS="$lt_save_ifs"
  3108.       test -z "$ac_dir" && ac_dir=.
  3109.       tmp_nm="$ac_dir/$lt_tmp_nm"
  3110.       if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then
  3111. # Check to see if the nm accepts a BSD-compat flag.
  3112. # Adding the `sed 1q' prevents false positives on HP-UX, which says:
  3113. #   nm: unknown option "B" ignored
  3114. # Tru64's nm complains that /dev/null is an invalid object file
  3115. case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in
  3116. */dev/null* | *'Invalid file or object type'*)
  3117.   lt_cv_path_NM="$tmp_nm -B"
  3118.   break
  3119.   ;;
  3120. *)
  3121.   case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in
  3122.   */dev/null*)
  3123.     lt_cv_path_NM="$tmp_nm -p"
  3124.     break
  3125.     ;;
  3126.   *)
  3127.     lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
  3128.     continue # so that we can try to find one that supports BSD flags
  3129.     ;;
  3130.   esac
  3131.   ;;
  3132. esac
  3133.       fi
  3134.     done
  3135.     IFS="$lt_save_ifs"
  3136.   done
  3137.   : ${lt_cv_path_NM=no}
  3138. fi
  3139. fi
  3140. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_NM" >&5
  3141. $as_echo "$lt_cv_path_NM" >&6; }
  3142. if test "$lt_cv_path_NM" != "no"; then
  3143.   NM="$lt_cv_path_NM"
  3144. else
  3145.   # Didn't find any BSD compatible name lister, look for dumpbin.
  3146.   if test -n "$ac_tool_prefix"; then
  3147.   for ac_prog in "dumpbin -symbols" "link -dump -symbols"
  3148.   do
  3149.     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
  3150. set dummy $ac_tool_prefix$ac_prog; ac_word=$2
  3151. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
  3152. $as_echo_n "checking for $ac_word... " >&6; }
  3153. if test "${ac_cv_prog_DUMPBIN+set}" = set; then :
  3154.   $as_echo_n "(cached) " >&6
  3155. else
  3156.   if test -n "$DUMPBIN"; then
  3157.   ac_cv_prog_DUMPBIN="$DUMPBIN" # Let the user override the test.
  3158. else
  3159. as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
  3160. for as_dir in $PATH
  3161. do
  3162.   IFS=$as_save_IFS
  3163.   test -z "$as_dir" && as_dir=.
  3164.     for ac_exec_ext in '' $ac_executable_extensions; do
  3165.   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
  3166.     ac_cv_prog_DUMPBIN="$ac_tool_prefix$ac_prog"
  3167.     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
  3168.     break 2
  3169.   fi
  3170. done
  3171.   done
  3172. IFS=$as_save_IFS
  3173. fi
  3174. fi
  3175. DUMPBIN=$ac_cv_prog_DUMPBIN
  3176. if test -n "$DUMPBIN"; then
  3177.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DUMPBIN" >&5
  3178. $as_echo "$DUMPBIN" >&6; }
  3179. else
  3180.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  3181. $as_echo "no" >&6; }
  3182. fi
  3183.     test -n "$DUMPBIN" && break
  3184.   done
  3185. fi
  3186. if test -z "$DUMPBIN"; then
  3187.   ac_ct_DUMPBIN=$DUMPBIN
  3188.   for ac_prog in "dumpbin -symbols" "link -dump -symbols"
  3189. do
  3190.   # Extract the first word of "$ac_prog", so it can be a program name with args.
  3191. set dummy $ac_prog; ac_word=$2
  3192. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
  3193. $as_echo_n "checking for $ac_word... " >&6; }
  3194. if test "${ac_cv_prog_ac_ct_DUMPBIN+set}" = set; then :
  3195.   $as_echo_n "(cached) " >&6
  3196. else
  3197.   if test -n "$ac_ct_DUMPBIN"; then
  3198.   ac_cv_prog_ac_ct_DUMPBIN="$ac_ct_DUMPBIN" # Let the user override the test.
  3199. else
  3200. as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
  3201. for as_dir in $PATH
  3202. do
  3203.   IFS=$as_save_IFS
  3204.   test -z "$as_dir" && as_dir=.
  3205.     for ac_exec_ext in '' $ac_executable_extensions; do
  3206.   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
  3207.     ac_cv_prog_ac_ct_DUMPBIN="$ac_prog"
  3208.     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
  3209.     break 2
  3210.   fi
  3211. done
  3212.   done
  3213. IFS=$as_save_IFS
  3214. fi
  3215. fi
  3216. ac_ct_DUMPBIN=$ac_cv_prog_ac_ct_DUMPBIN
  3217. if test -n "$ac_ct_DUMPBIN"; then
  3218.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DUMPBIN" >&5
  3219. $as_echo "$ac_ct_DUMPBIN" >&6; }
  3220. else
  3221.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  3222. $as_echo "no" >&6; }
  3223. fi
  3224.   test -n "$ac_ct_DUMPBIN" && break
  3225. done
  3226.   if test "x$ac_ct_DUMPBIN" = x; then
  3227.     DUMPBIN=":"
  3228.   else
  3229.     case $cross_compiling:$ac_tool_warned in
  3230. yes:)
  3231. { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
  3232. $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
  3233. ac_tool_warned=yes ;;
  3234. esac
  3235.     DUMPBIN=$ac_ct_DUMPBIN
  3236.   fi
  3237. fi
  3238.   if test "$DUMPBIN" != ":"; then
  3239.     NM="$DUMPBIN"
  3240.   fi
  3241. fi
  3242. test -z "$NM" && NM=nm
  3243. { $as_echo "$as_me:${as_lineno-$LINENO}: checking the name lister ($NM) interface" >&5
  3244. $as_echo_n "checking the name lister ($NM) interface... " >&6; }
  3245. if test "${lt_cv_nm_interface+set}" = set; then :
  3246.   $as_echo_n "(cached) " >&6
  3247. else
  3248.   lt_cv_nm_interface="BSD nm"
  3249.   echo "int some_variable = 0;" > conftest.$ac_ext
  3250.   (eval echo ""$as_me:11413: $ac_compile"" >&5)
  3251.   (eval "$ac_compile" 2>conftest.err)
  3252.   cat conftest.err >&5
  3253.   (eval echo ""$as_me:11416: $NM \"conftest.$ac_objext\""" >&5)
  3254.   (eval "$NM "conftest.$ac_objext"" 2>conftest.err > conftest.out)
  3255.   cat conftest.err >&5
  3256.   (eval echo ""$as_me:11419: output"" >&5)
  3257.   cat conftest.out >&5
  3258.   if $GREP 'External.*some_variable' conftest.out > /dev/null; then
  3259.     lt_cv_nm_interface="MS dumpbin"
  3260.   fi
  3261.   rm -f conftest*
  3262. fi
  3263. { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_nm_interface" >&5
  3264. $as_echo "$lt_cv_nm_interface" >&6; }
  3265.   ac_tool_prefix=$gmp_save_ac_tool_prefix
  3266. fi
  3267. if test -z "$gmp_user_NM"; then
  3268.                         eval nmflags="$nm${abi1}_flags"
  3269.   test -n "$nmflags" || eval nmflags="$nm${abi2}_flags"
  3270.   if test -n "$nmflags"; then
  3271.     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for extra nm flags" >&5
  3272. $as_echo_n "checking for extra nm flags... " >&6; }
  3273.     NM="$NM $nmflags"
  3274.     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $nmflags" >&5
  3275. $as_echo "$nmflags" >&6; }
  3276.   fi
  3277. fi
  3278. case $host in
  3279.   # FIXME: On AIX 3 and 4, $libname.a is included in libtool
  3280.   # $library_names_spec, so libgmp.a becomes a symlink to libgmp.so, making
  3281.   # it impossible to build shared and static libraries simultaneously.
  3282.   # Disable shared libraries by default, but let the user override with
  3283.   # --enable-shared --disable-static.
  3284.   #
  3285.   # FIXME: This $libname.a problem looks like it might apply to *-*-amigaos*
  3286.   # and *-*-os2* too, but wait for someone to test this before worrying
  3287.   # about it.  If there is a problem then of course libtool is the right
  3288.   # place to fix it.
  3289.   #
  3290.   *-*-aix[34]*)
  3291.     if test -z "$enable_shared"; then enable_shared=no; fi ;;
  3292. esac
  3293. # Configs for Windows DLLs.
  3294. enable_win32_dll=yes
  3295. case $host in
  3296. *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-cegcc*)
  3297.   if test -n "$ac_tool_prefix"; then
  3298.   # Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args.
  3299. set dummy ${ac_tool_prefix}as; ac_word=$2
  3300. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
  3301. $as_echo_n "checking for $ac_word... " >&6; }
  3302. if test "${ac_cv_prog_AS+set}" = set; then :
  3303.   $as_echo_n "(cached) " >&6
  3304. else
  3305.   if test -n "$AS"; then
  3306.   ac_cv_prog_AS="$AS" # Let the user override the test.
  3307. else
  3308. as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
  3309. for as_dir in $PATH
  3310. do
  3311.   IFS=$as_save_IFS
  3312.   test -z "$as_dir" && as_dir=.
  3313.     for ac_exec_ext in '' $ac_executable_extensions; do
  3314.   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
  3315.     ac_cv_prog_AS="${ac_tool_prefix}as"
  3316.     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
  3317.     break 2
  3318.   fi
  3319. done
  3320.   done
  3321. IFS=$as_save_IFS
  3322. fi
  3323. fi
  3324. AS=$ac_cv_prog_AS
  3325. if test -n "$AS"; then
  3326.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AS" >&5
  3327. $as_echo "$AS" >&6; }
  3328. else
  3329.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  3330. $as_echo "no" >&6; }
  3331. fi
  3332. fi
  3333. if test -z "$ac_cv_prog_AS"; then
  3334.   ac_ct_AS=$AS
  3335.   # Extract the first word of "as", so it can be a program name with args.
  3336. set dummy as; ac_word=$2
  3337. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
  3338. $as_echo_n "checking for $ac_word... " >&6; }
  3339. if test "${ac_cv_prog_ac_ct_AS+set}" = set; then :
  3340.   $as_echo_n "(cached) " >&6
  3341. else
  3342.   if test -n "$ac_ct_AS"; then
  3343.   ac_cv_prog_ac_ct_AS="$ac_ct_AS" # Let the user override the test.
  3344. else
  3345. as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
  3346. for as_dir in $PATH
  3347. do
  3348.   IFS=$as_save_IFS
  3349.   test -z "$as_dir" && as_dir=.
  3350.     for ac_exec_ext in '' $ac_executable_extensions; do
  3351.   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
  3352.     ac_cv_prog_ac_ct_AS="as"
  3353.     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
  3354.     break 2
  3355.   fi
  3356. done
  3357.   done
  3358. IFS=$as_save_IFS
  3359. fi
  3360. fi
  3361. ac_ct_AS=$ac_cv_prog_ac_ct_AS
  3362. if test -n "$ac_ct_AS"; then
  3363.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AS" >&5
  3364. $as_echo "$ac_ct_AS" >&6; }
  3365. else
  3366.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  3367. $as_echo "no" >&6; }
  3368. fi
  3369.   if test "x$ac_ct_AS" = x; then
  3370.     AS="false"
  3371.   else
  3372.     case $cross_compiling:$ac_tool_warned in
  3373. yes:)
  3374. { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
  3375. $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
  3376. ac_tool_warned=yes ;;
  3377. esac
  3378.     AS=$ac_ct_AS
  3379.   fi
  3380. else
  3381.   AS="$ac_cv_prog_AS"
  3382. fi
  3383.   if test -n "$ac_tool_prefix"; then
  3384.   # Extract the first word of "${ac_tool_prefix}dlltool", so it can be a program name with args.
  3385. set dummy ${ac_tool_prefix}dlltool; ac_word=$2
  3386. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
  3387. $as_echo_n "checking for $ac_word... " >&6; }
  3388. if test "${ac_cv_prog_DLLTOOL+set}" = set; then :
  3389.   $as_echo_n "(cached) " >&6
  3390. else
  3391.   if test -n "$DLLTOOL"; then
  3392.   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
  3393. else
  3394. as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
  3395. for as_dir in $PATH
  3396. do
  3397.   IFS=$as_save_IFS
  3398.   test -z "$as_dir" && as_dir=.
  3399.     for ac_exec_ext in '' $ac_executable_extensions; do
  3400.   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
  3401.     ac_cv_prog_DLLTOOL="${ac_tool_prefix}dlltool"
  3402.     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
  3403.     break 2
  3404.   fi
  3405. done
  3406.   done
  3407. IFS=$as_save_IFS
  3408. fi
  3409. fi
  3410. DLLTOOL=$ac_cv_prog_DLLTOOL
  3411. if test -n "$DLLTOOL"; then
  3412.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL" >&5
  3413. $as_echo "$DLLTOOL" >&6; }
  3414. else
  3415.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  3416. $as_echo "no" >&6; }
  3417. fi
  3418. fi
  3419. if test -z "$ac_cv_prog_DLLTOOL"; then
  3420.   ac_ct_DLLTOOL=$DLLTOOL
  3421.   # Extract the first word of "dlltool", so it can be a program name with args.
  3422. set dummy dlltool; ac_word=$2
  3423. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
  3424. $as_echo_n "checking for $ac_word... " >&6; }
  3425. if test "${ac_cv_prog_ac_ct_DLLTOOL+set}" = set; then :
  3426.   $as_echo_n "(cached) " >&6
  3427. else
  3428.   if test -n "$ac_ct_DLLTOOL"; then
  3429.   ac_cv_prog_ac_ct_DLLTOOL="$ac_ct_DLLTOOL" # Let the user override the test.
  3430. else
  3431. as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
  3432. for as_dir in $PATH
  3433. do
  3434.   IFS=$as_save_IFS
  3435.   test -z "$as_dir" && as_dir=.
  3436.     for ac_exec_ext in '' $ac_executable_extensions; do
  3437.   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
  3438.     ac_cv_prog_ac_ct_DLLTOOL="dlltool"
  3439.     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
  3440.     break 2
  3441.   fi
  3442. done
  3443.   done
  3444. IFS=$as_save_IFS
  3445. fi
  3446. fi
  3447. ac_ct_DLLTOOL=$ac_cv_prog_ac_ct_DLLTOOL
  3448. if test -n "$ac_ct_DLLTOOL"; then
  3449.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLTOOL" >&5
  3450. $as_echo "$ac_ct_DLLTOOL" >&6; }
  3451. else
  3452.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  3453. $as_echo "no" >&6; }
  3454. fi
  3455.   if test "x$ac_ct_DLLTOOL" = x; then
  3456.     DLLTOOL="false"
  3457.   else
  3458.     case $cross_compiling:$ac_tool_warned in
  3459. yes:)
  3460. { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
  3461. $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
  3462. ac_tool_warned=yes ;;
  3463. esac
  3464.     DLLTOOL=$ac_ct_DLLTOOL
  3465.   fi
  3466. else
  3467.   DLLTOOL="$ac_cv_prog_DLLTOOL"
  3468. fi
  3469.   if test -n "$ac_tool_prefix"; then
  3470.   # Extract the first word of "${ac_tool_prefix}objdump", so it can be a program name with args.
  3471. set dummy ${ac_tool_prefix}objdump; ac_word=$2
  3472. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
  3473. $as_echo_n "checking for $ac_word... " >&6; }
  3474. if test "${ac_cv_prog_OBJDUMP+set}" = set; then :
  3475.   $as_echo_n "(cached) " >&6
  3476. else
  3477.   if test -n "$OBJDUMP"; then
  3478.   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
  3479. else
  3480. as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
  3481. for as_dir in $PATH
  3482. do
  3483.   IFS=$as_save_IFS
  3484.   test -z "$as_dir" && as_dir=.
  3485.     for ac_exec_ext in '' $ac_executable_extensions; do
  3486.   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
  3487.     ac_cv_prog_OBJDUMP="${ac_tool_prefix}objdump"
  3488.     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
  3489.     break 2
  3490.   fi
  3491. done
  3492.   done
  3493. IFS=$as_save_IFS
  3494. fi
  3495. fi
  3496. OBJDUMP=$ac_cv_prog_OBJDUMP
  3497. if test -n "$OBJDUMP"; then
  3498.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
  3499. $as_echo "$OBJDUMP" >&6; }
  3500. else
  3501.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  3502. $as_echo "no" >&6; }
  3503. fi
  3504. fi
  3505. if test -z "$ac_cv_prog_OBJDUMP"; then
  3506.   ac_ct_OBJDUMP=$OBJDUMP
  3507.   # Extract the first word of "objdump", so it can be a program name with args.
  3508. set dummy objdump; ac_word=$2
  3509. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
  3510. $as_echo_n "checking for $ac_word... " >&6; }
  3511. if test "${ac_cv_prog_ac_ct_OBJDUMP+set}" = set; then :
  3512.   $as_echo_n "(cached) " >&6
  3513. else
  3514.   if test -n "$ac_ct_OBJDUMP"; then
  3515.   ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test.
  3516. else
  3517. as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
  3518. for as_dir in $PATH
  3519. do
  3520.   IFS=$as_save_IFS
  3521.   test -z "$as_dir" && as_dir=.
  3522.     for ac_exec_ext in '' $ac_executable_extensions; do
  3523.   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
  3524.     ac_cv_prog_ac_ct_OBJDUMP="objdump"
  3525.     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
  3526.     break 2
  3527.   fi
  3528. done
  3529.   done
  3530. IFS=$as_save_IFS
  3531. fi
  3532. fi
  3533. ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP
  3534. if test -n "$ac_ct_OBJDUMP"; then
  3535.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
  3536. $as_echo "$ac_ct_OBJDUMP" >&6; }
  3537. else
  3538.   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
  3539. $as_echo "no" >&6; }
  3540. fi