acinclude.m4
上传用户:qaz666999
上传日期:2022-08-06
资源大小:2570k
文件大小:116k
源码类别:

数学计算

开发平台:

Unix_Linux

  1. dnl  GMP specific autoconf macros
  2. dnl  Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2009 Free Software
  3. dnl  Foundation, Inc.
  4. dnl
  5. dnl  This file is part of the GNU MP Library.
  6. dnl
  7. dnl  The GNU MP Library is free software; you can redistribute it and/or modify
  8. dnl  it under the terms of the GNU Lesser General Public License as published
  9. dnl  by the Free Software Foundation; either version 3 of the License, or (at
  10. dnl  your option) any later version.
  11. dnl
  12. dnl  The GNU MP Library is distributed in the hope that it will be useful, but
  13. dnl  WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  14. dnl  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  15. dnl  License for more details.
  16. dnl
  17. dnl  You should have received a copy of the GNU Lesser General Public License
  18. dnl  along with the GNU MP Library.  If not, see http://www.gnu.org/licenses/.
  19. dnl  Some tests use, or must delete, the default compiler output.  The
  20. dnl  possible filenames are based on what autoconf looks for, namely
  21. dnl
  22. dnl    a.out - normal unix style
  23. dnl    b.out - i960 systems, including gcc there
  24. dnl    a.exe - djgpp
  25. dnl    a_out.exe - OpenVMS DEC C called via GNV wrapper (gnv.sourceforge.net)
  26. dnl    conftest.exe - various DOS compilers
  27. define(IA64_PATTERN,
  28. [[ia64*-*-* | itanium-*-* | itanium2-*-*]])
  29. dnl  Need to be careful not to match m6811, m6812, m68hc11 and m68hc12, all
  30. dnl  of which config.sub accepts.  (Though none of which are likely to work
  31. dnl  with GMP.)
  32. dnl
  33. define(M68K_PATTERN,
  34. [[m68k-*-* | m68[0-9][0-9][0-9]-*-*]])
  35. define(POWERPC64_PATTERN,
  36. [[powerpc64-*-* | powerpc64le-*-* | powerpc620-*-* | powerpc630-*-* | powerpc970-*-* | power[3-9]-*-*]])
  37. define(X86_PATTERN,
  38. [[i?86*-*-* | k[5-8]*-*-* | pentium*-*-* | athlon-*-* | viac3*-*-* | geode*-*-* | atom-*-*]])
  39. define(X86_64_PATTERN,
  40. [[athlon64-*-* | pentium4-*-* | atom-*-* | core2-*-* | corei-*-* | x86_64-*-* | nano-*-*]])
  41. dnl  GMP_FAT_SUFFIX(DSTVAR, DIRECTORY)
  42. dnl  ---------------------------------
  43. dnl  Emit code to set shell variable DSTVAR to the suffix for a fat binary
  44. dnl  routine from DIRECTORY.  DIRECTORY can be a shell expression like $foo
  45. dnl  etc.
  46. dnl
  47. dnl  The suffix is directory separators / or  changed to underscores, and
  48. dnl  if there's more than one directory part, then the first is dropped.
  49. dnl
  50. dnl  For instance,
  51. dnl
  52. dnl      x86         ->  x86
  53. dnl      x86/k6      ->  k6
  54. dnl      x86/k6/mmx  ->  k6_mmx
  55. define(GMP_FAT_SUFFIX,
  56. [[$1=`echo $2 | sed -e '///s:^[^/]*/::' -e 's:[\/]:_:g'`]])
  57. dnl  GMP_REMOVE_FROM_LIST(listvar,item)
  58. dnl  ----------------------------------
  59. dnl  Emit code to remove any occurrence of ITEM from $LISTVAR.  ITEM can be a
  60. dnl  shell expression like $foo if desired.
  61. define(GMP_REMOVE_FROM_LIST,
  62. [remove_from_list_tmp=
  63. for remove_from_list_i in $[][$1]; do
  64.   if test $remove_from_list_i = [$2]; then :;
  65.   else
  66.      remove_from_list_tmp="$remove_from_list_tmp $remove_from_list_i"
  67.   fi
  68. done
  69. [$1]=$remove_from_list_tmp
  70. ])
  71. dnl  GMP_STRIP_PATH(subdir)
  72. dnl  ----------------------
  73. dnl  Strip entries */subdir from $path and $fat_path.
  74. define(GMP_STRIP_PATH,
  75. [GMP_STRIP_PATH_VAR(path, [$1])
  76. GMP_STRIP_PATH_VAR(fat_path, [$1])
  77. ])
  78. define(GMP_STRIP_PATH_VAR,
  79. [tmp_path=
  80. for i in $[][$1]; do
  81.   case $i in
  82.     */[$2]) ;;
  83.     *) tmp_path="$tmp_path $i" ;;
  84.   esac
  85. done
  86. [$1]="$tmp_path"
  87. ])
  88. dnl  GMP_INCLUDE_GMP_H
  89. dnl  -----------------
  90. dnl  Expand to the right way to #include gmp-h.in.  This must be used
  91. dnl  instead of gmp.h, since that file isn't generated until the end of the
  92. dnl  configure.
  93. dnl
  94. dnl  Dummy value for GMP_LIMB_BITS is enough
  95. dnl  for all current configure-time uses of gmp.h.
  96. define(GMP_INCLUDE_GMP_H,
  97. [[#define __GMP_WITHIN_CONFIGURE 1   /* ignore template stuff */
  98. #define GMP_NAIL_BITS $GMP_NAIL_BITS
  99. #define GMP_LIMB_BITS 123
  100. $DEFN_LONG_LONG_LIMB
  101. #include "$srcdir/gmp-h.in"]
  102. ])
  103. dnl  GMP_HEADER_GETVAL(NAME,FILE)
  104. dnl  ----------------------------
  105. dnl  Expand at autoconf time to the value of a "#define NAME" from the given
  106. dnl  FILE.  The regexps here aren't very rugged, but are enough for gmp.
  107. dnl  /dev/null as a parameter prevents a hang if $2 is accidentally omitted.
  108. define(GMP_HEADER_GETVAL,
  109. [patsubst(patsubst(
  110. esyscmd([grep "^#define $1 " $2 /dev/null 2>/dev/null]),
  111. [^.*$1[  ]+],[]),
  112. [[
  113.   ]*$],[])])
  114. dnl  GMP_VERSION
  115. dnl  -----------
  116. dnl  The gmp version number, extracted from the #defines in gmp-h.in at
  117. dnl  autoconf time.  Two digits like 3.0 if patchlevel <= 0, or three digits
  118. dnl  like 3.0.1 if patchlevel > 0.
  119. define(GMP_VERSION,
  120. [GMP_HEADER_GETVAL(__GNU_MP_VERSION,gmp-h.in)[]dnl
  121. .GMP_HEADER_GETVAL(__GNU_MP_VERSION_MINOR,gmp-h.in)[]dnl
  122. .GMP_HEADER_GETVAL(__GNU_MP_VERSION_PATCHLEVEL,gmp-h.in)])
  123. dnl  GMP_SUBST_CHECK_FUNCS(func,...)
  124. dnl  ------------------------------
  125. dnl  Setup an AC_SUBST of HAVE_FUNC_01 for each argument.
  126. AC_DEFUN([GMP_SUBST_CHECK_FUNCS],
  127. [m4_if([$1],,,
  128. [_GMP_SUBST_CHECK_FUNCS(ac_cv_func_[$1],HAVE_[]m4_translit([$1],[a-z],[A-Z])_01)
  129. GMP_SUBST_CHECK_FUNCS(m4_shift($@))])])
  130. dnl  Called: _GMP_SUBST_CHECK_FUNCS(cachevar,substvar)
  131. AC_DEFUN([_GMP_SUBST_CHECK_FUNCS],
  132. [case $[$1] in
  133. yes) AC_SUBST([$2],1) ;;
  134. no)  [$2]=0 ;;
  135. esac
  136. ])
  137. dnl  GMP_SUBST_CHECK_HEADERS(foo.h,...)
  138. dnl  ----------------------------------
  139. dnl  Setup an AC_SUBST of HAVE_FOO_H_01 for each argument.
  140. AC_DEFUN([GMP_SUBST_CHECK_HEADERS],
  141. [m4_if([$1],,,
  142. [_GMP_SUBST_CHECK_HEADERS(ac_cv_header_[]m4_translit([$1],[./],[__]),
  143. HAVE_[]m4_translit([$1],[a-z./],[A-Z__])_01)
  144. GMP_SUBST_CHECK_HEADERS(m4_shift($@))])])
  145. dnl  Called: _GMP_SUBST_CHECK_HEADERS(cachevar,substvar)
  146. AC_DEFUN([_GMP_SUBST_CHECK_HEADERS],
  147. [case $[$1] in
  148. yes) AC_SUBST([$2],1) ;;
  149. no)  [$2]=0 ;;
  150. esac
  151. ])
  152. dnl  GMP_COMPARE_GE(A1,B1, A2,B2, ...)
  153. dnl  ---------------------------------
  154. dnl  Compare two version numbers A1.A2.etc and B1.B2.etc.  Set
  155. dnl  $gmp_compare_ge to yes or no according to the result.  The A parts
  156. dnl  should be variables, the B parts fixed numbers.  As many parts as
  157. dnl  desired can be included.  An empty string in an A part is taken to be
  158. dnl  zero, the B parts should be non-empty and non-zero.
  159. dnl
  160. dnl  For example,
  161. dnl
  162. dnl      GMP_COMPARE($major,10, $minor,3, $subminor,1)
  163. dnl
  164. dnl  would test whether $major.$minor.$subminor is greater than or equal to
  165. dnl  10.3.1.
  166. AC_DEFUN([GMP_COMPARE_GE],
  167. [gmp_compare_ge=no
  168. GMP_COMPARE_GE_INTERNAL($@)
  169. ])
  170. AC_DEFUN([GMP_COMPARE_GE_INTERNAL],
  171. [ifelse(len([$3]),0,
  172. [if test -n "$1" && test "$1" -ge $2; then
  173.   gmp_compare_ge=yes
  174. fi],
  175. [if test -n "$1"; then
  176.   if test "$1" -gt $2; then
  177.     gmp_compare_ge=yes
  178.   else
  179.     if test "$1" -eq $2; then
  180.       GMP_COMPARE_GE_INTERNAL(m4_shift(m4_shift($@)))
  181.     fi
  182.   fi
  183. fi])
  184. ])
  185. dnl  GMP_PROG_AR
  186. dnl  -----------
  187. dnl  GMP additions to $AR.
  188. dnl
  189. dnl  A cross-"ar" may be necessary when cross-compiling since the build
  190. dnl  system "ar" might try to interpret the object files to build a symbol
  191. dnl  table index, hence the use of AC_CHECK_TOOL.
  192. dnl
  193. dnl  A user-selected $AR is always left unchanged.  AC_CHECK_TOOL is still
  194. dnl  run to get the "checking" message printed though.
  195. dnl
  196. dnl  If extra flags are added to AR, then ac_cv_prog_AR and
  197. dnl  ac_cv_prog_ac_ct_AR are set too, since libtool (cvs 2003-03-31 at
  198. dnl  least) will do an AC_CHECK_TOOL and that will AR from one of those two
  199. dnl  cached variables.  (ac_cv_prog_AR is used if there's an ac_tool_prefix,
  200. dnl  or ac_cv_prog_ac_ct_AR is used otherwise.)  FIXME: This is highly
  201. dnl  dependent on autoconf internals, perhaps it'd work to put our extra
  202. dnl  flags into AR_FLAGS instead.
  203. dnl
  204. dnl  $AR_FLAGS is set to "cq" rather than leaving it to libtool "cru".  The
  205. dnl  latter fails when libtool goes into piecewise mode and is unlucky
  206. dnl  enough to have two same-named objects in separate pieces, as happens
  207. dnl  for instance to random.o (and others) on vax-dec-ultrix4.5.  Naturally
  208. dnl  a user-selected $AR_FLAGS is left unchanged.
  209. dnl
  210. dnl  For reference, $ARFLAGS is used by automake (1.8) for its ".a" archive
  211. dnl  file rules.  This doesn't get used by the piecewise linking, so we
  212. dnl  leave it at the default "cru".
  213. dnl
  214. dnl  FIXME: Libtool 1.5.2 has its own arrangements for "cq", but that version
  215. dnl  is broken in other ways.  When we can upgrade, remove the forcible
  216. dnl  AR_FLAGS=cq.
  217. AC_DEFUN([GMP_PROG_AR],
  218. [dnl  Want to establish $AR before libtool initialization.
  219. AC_BEFORE([$0],[AC_PROG_LIBTOOL])
  220. gmp_user_AR=$AR
  221. AC_CHECK_TOOL(AR, ar, ar)
  222. if test -z "$gmp_user_AR"; then
  223.                         eval arflags="$ar${abi1}_flags"
  224.   test -n "$arflags" || eval arflags="$ar${abi2}_flags"
  225.   if test -n "$arflags"; then
  226.     AC_MSG_CHECKING([for extra ar flags])
  227.     AR="$AR $arflags"
  228.     ac_cv_prog_AR="$AR $arflags"
  229.     ac_cv_prog_ac_ct_AR="$AR $arflags"
  230.     AC_MSG_RESULT([$arflags])
  231.   fi
  232. fi
  233. if test -z "$AR_FLAGS"; then
  234.   AR_FLAGS=cq
  235. fi
  236. ])
  237. dnl  GMP_PROG_M4
  238. dnl  -----------
  239. dnl  Find a working m4, either in $PATH or likely locations, and setup $M4
  240. dnl  and an AC_SUBST accordingly.  If $M4 is already set then it's a user
  241. dnl  choice and is accepted with no checks.  GMP_PROG_M4 is like
  242. dnl  AC_PATH_PROG or AC_CHECK_PROG, but tests each m4 found to see if it's
  243. dnl  good enough.
  244. dnl
  245. dnl  See mpn/asm-defs.m4 for details on the known bad m4s.
  246. AC_DEFUN([GMP_PROG_M4],
  247. [AC_ARG_VAR(M4,[m4 macro processor])
  248. AC_CACHE_CHECK([for suitable m4],
  249.                 gmp_cv_prog_m4,
  250. [if test -n "$M4"; then
  251.   gmp_cv_prog_m4="$M4"
  252. else
  253.   cat >conftest.m4 <<EOF
  254. dnl  Must protect this against being expanded during autoconf m4!
  255. dnl  Dont put "dnl"s in this as autoconf will flag an error for unexpanded
  256. dnl  macros.
  257. [define(dollarhash,``$][#'')ifelse(dollarhash(x),1,`define(t1,Y)',
  258. ``bad: $][# not supported (SunOS /usr/bin/m4)
  259. '')ifelse(eval(89),89,`define(t2,Y)',
  260. `bad: eval() doesnt support 8 or 9 in a constant (OpenBSD 2.6 m4)
  261. ')ifelse(t1`'t2,YY,`good
  262. ')]
  263. EOF
  264. dnl ' <- balance the quotes for emacs sh-mode
  265.   echo "trying m4" >&AC_FD_CC
  266.   gmp_tmp_val=`(m4 conftest.m4) 2>&AC_FD_CC`
  267.   echo "$gmp_tmp_val" >&AC_FD_CC
  268.   if test "$gmp_tmp_val" = good; then
  269.     gmp_cv_prog_m4="m4"
  270.   else
  271.     IFS="${IFS=  }"; ac_save_ifs="$IFS"; IFS=":"
  272. dnl $ac_dummy forces splitting on constant user-supplied paths.
  273. dnl POSIX.2 word splitting is done only on the output of word expansions,
  274. dnl not every word.  This closes a longstanding sh security hole.
  275.     ac_dummy="$PATH:/usr/5bin"
  276.     for ac_dir in $ac_dummy; do
  277.       test -z "$ac_dir" && ac_dir=.
  278.       echo "trying $ac_dir/m4" >&AC_FD_CC
  279.       gmp_tmp_val=`($ac_dir/m4 conftest.m4) 2>&AC_FD_CC`
  280.       echo "$gmp_tmp_val" >&AC_FD_CC
  281.       if test "$gmp_tmp_val" = good; then
  282.         gmp_cv_prog_m4="$ac_dir/m4"
  283.         break
  284.       fi
  285.     done
  286.     IFS="$ac_save_ifs"
  287.     if test -z "$gmp_cv_prog_m4"; then
  288.       AC_MSG_ERROR([No usable m4 in $PATH or /usr/5bin (see config.log for reasons).])
  289.     fi
  290.   fi
  291.   rm -f conftest.m4
  292. fi])
  293. M4="$gmp_cv_prog_m4"
  294. AC_SUBST(M4)
  295. ])
  296. dnl  GMP_M4_M4WRAP_SPURIOUS
  297. dnl  ----------------------
  298. dnl  Check for spurious output from m4wrap(), as described in mpn/asm-defs.m4.
  299. dnl
  300. dnl  The following systems have been seen with the problem.
  301. dnl
  302. dnl  - Unicos alpha, but its assembler doesn't seem to mind.
  303. dnl  - MacOS X Darwin, its assembler fails.
  304. dnl  - NetBSD 1.4.1 m68k, and gas 1.92.3 there gives a warning and ignores
  305. dnl    the bad last line since it doesn't have a newline.
  306. dnl  - NetBSD 1.4.2 alpha, but its assembler doesn't seem to mind.
  307. dnl  - HP-UX ia64.
  308. dnl
  309. dnl  Enhancement: Maybe this could be in GMP_PROG_M4, and attempt to prefer
  310. dnl  an m4 with a working m4wrap, if it can be found.
  311. AC_DEFUN([GMP_M4_M4WRAP_SPURIOUS],
  312. [AC_REQUIRE([GMP_PROG_M4])
  313. AC_CACHE_CHECK([if m4wrap produces spurious output],
  314.                gmp_cv_m4_m4wrap_spurious,
  315. [# hide the d-n-l from autoconf's error checking
  316. tmp_d_n_l=d""nl
  317. cat >conftest.m4 <<EOF
  318. [changequote({,})define(x,)m4wrap({x})$tmp_d_n_l]
  319. EOF
  320. echo test input is >&AC_FD_CC
  321. cat conftest.m4 >&AC_FD_CC
  322. tmp_chars=`$M4 conftest.m4 | wc -c`
  323. echo produces $tmp_chars chars output >&AC_FD_CC
  324. rm -f conftest.m4
  325. if test $tmp_chars = 0; then
  326.   gmp_cv_m4_m4wrap_spurious=no
  327. else
  328.   gmp_cv_m4_m4wrap_spurious=yes
  329. fi
  330. ])
  331. GMP_DEFINE_RAW(["define(<M4WRAP_SPURIOUS>,<$gmp_cv_m4_m4wrap_spurious>)"])
  332. ])
  333. dnl  GMP_PROG_NM
  334. dnl  -----------
  335. dnl  GMP additions to libtool AC_PROG_NM.
  336. dnl
  337. dnl  Note that if AC_PROG_NM can't find a working nm it still leaves
  338. dnl  $NM set to "nm", so $NM can't be assumed to actually work.
  339. dnl
  340. dnl  A user-selected $NM is always left unchanged.  AC_PROG_NM is still run
  341. dnl  to get the "checking" message printed though.
  342. dnl
  343. dnl  Perhaps it'd be worthwhile checking that nm works, by running it on an
  344. dnl  actual object file.  For instance on sparcv9 solaris old versions of
  345. dnl  GNU nm don't recognise 64-bit objects.  Checking would give a better
  346. dnl  error message than just a failure in later tests like GMP_ASM_W32 etc.
  347. dnl
  348. dnl  On the other hand it's not really normal autoconf practice to take too
  349. dnl  much trouble over detecting a broken set of tools.  And libtool doesn't
  350. dnl  do anything at all for say ranlib or strip.  So for now we're inclined
  351. dnl  to just demand that the user provides a coherent environment.
  352. AC_DEFUN([GMP_PROG_NM],
  353. [dnl  Make sure we're the first to call AC_PROG_NM, so our extra flags are
  354. dnl   used by everyone.
  355. AC_BEFORE([$0],[AC_PROG_NM])
  356. gmp_user_NM=$NM
  357. AC_PROG_NM
  358. # FIXME: When cross compiling (ie. $ac_tool_prefix not empty), libtool
  359. # defaults to plain "nm" if a "${ac_tool_prefix}nm" is not found.  In this
  360. # case run it again to try the native "nm", firstly so that likely locations
  361. # are searched, secondly so that -B or -p are added if necessary for BSD
  362. # format.  This is necessary for instance on OSF with "./configure
  363. # --build=alphaev5-dec-osf --host=alphaev6-dec-osf".
  364. #
  365. if test -z "$gmp_user_NM" && test -n "$ac_tool_prefix" && test "$NM" = nm; then
  366.   $as_unset lt_cv_path_NM
  367.   gmp_save_ac_tool_prefix=$ac_tool_prefix
  368.   ac_tool_prefix=
  369.   NM=
  370.   AC_PROG_NM
  371.   ac_tool_prefix=$gmp_save_ac_tool_prefix
  372. fi
  373. if test -z "$gmp_user_NM"; then
  374.                         eval nmflags="$nm${abi1}_flags"
  375.   test -n "$nmflags" || eval nmflags="$nm${abi2}_flags"
  376.   if test -n "$nmflags"; then
  377.     AC_MSG_CHECKING([for extra nm flags])
  378.     NM="$NM $nmflags"
  379.     AC_MSG_RESULT([$nmflags])
  380.   fi
  381. fi
  382. ])
  383. dnl  GMP_PROG_CC_WORKS(cc+cflags,[ACTION-IF-WORKS][,ACTION-IF-NOT-WORKS])
  384. dnl  --------------------------------------------------------------------
  385. dnl  Check if cc+cflags can compile and link.
  386. dnl
  387. dnl  This test is designed to be run repeatedly with different cc+cflags
  388. dnl  selections, so the result is not cached.
  389. dnl
  390. dnl  For a native build, meaning $cross_compiling == no, we require that the
  391. dnl  generated program will run.  This is the same as AC_PROG_CC does in
  392. dnl  _AC_COMPILER_EXEEXT_WORKS, and checking here will ensure we don't pass
  393. dnl  a CC/CFLAGS combination that it rejects.
  394. dnl
  395. dnl  sparc-*-solaris2.7 can compile ABI=64 but won't run it if the kernel
  396. dnl  was booted in 32-bit mode.  The effect of requiring the compiler output
  397. dnl  will run is that a plain native "./configure" falls back on ABI=32, but
  398. dnl  ABI=64 is still available as a cross-compile.
  399. dnl
  400. dnl  The various specific problems we try to detect are done in separate
  401. dnl  compiles.  Although this is probably a bit slower than one test
  402. dnl  program, it makes it easy to indicate the problem in AC_MSG_RESULT,
  403. dnl  hence giving the user a clue about why we rejected the compiler.
  404. AC_DEFUN([GMP_PROG_CC_WORKS],
  405. [AC_MSG_CHECKING([compiler $1])
  406. gmp_prog_cc_works=yes
  407. # first see a simple "main()" works, then go on to other checks
  408. GMP_PROG_CC_WORKS_PART([$1], [])
  409. GMP_PROG_CC_WORKS_PART([$1], [function pointer return],
  410. [/* The following provokes an internal error from gcc 2.95.2 -mpowerpc64
  411.    (without -maix64), hence detecting an unusable compiler */
  412. void *g() { return (void *) 0; }
  413. void *f() { return g(); }
  414. ])
  415. GMP_PROG_CC_WORKS_PART([$1], [cmov instruction],
  416. [/* The following provokes an invalid instruction syntax from i386 gcc
  417.    -march=pentiumpro on Solaris 2.8.  The native sun assembler
  418.    requires a non-standard syntax for cmov which gcc (as of 2.95.2 at
  419.    least) doesn't know.  */
  420. int n;
  421. int cmov () { return (n >= 0 ? n : 0); }
  422. ])
  423. GMP_PROG_CC_WORKS_PART([$1], [double -> ulong conversion],
  424. [/* The following provokes a linker invocation problem with gcc 3.0.3
  425.    on AIX 4.3 under "-maix64 -mpowerpc64 -mcpu=630".  The -mcpu=630
  426.    option causes gcc to incorrectly select the 32-bit libgcc.a, not
  427.    the 64-bit one, and consequently it misses out on the __fixunsdfdi
  428.    helper (double -> uint64 conversion).  */
  429. double d;
  430. unsigned long gcc303 () { return (unsigned long) d; }
  431. ])
  432. GMP_PROG_CC_WORKS_PART([$1], [double negation],
  433. [/* The following provokes an error from hppa gcc 2.95 under -mpa-risc-2-0 if
  434.    the assembler doesn't know hppa 2.0 instructions.  fneg is a 2.0
  435.    instruction, and a negation like this comes out using it.  */
  436. double fneg_data;
  437. unsigned long fneg () { return -fneg_data; }
  438. ])
  439. GMP_PROG_CC_WORKS_PART([$1], [double -> float conversion],
  440. [/* The following makes gcc 3.3 -march=pentium4 generate an SSE2 xmm insn
  441.    (cvtsd2ss) which will provoke an error if the assembler doesn't recognise
  442.    those instructions.  Not sure how much of the gmp code will come out
  443.    wanting sse2, but it's easiest to reject an option we know is bad.  */
  444. double ftod_data;
  445. float ftod () { return (float) ftod_data; }
  446. ])
  447. GMP_PROG_CC_WORKS_PART([$1], [gnupro alpha ev6 char spilling],
  448. [/* The following provokes an internal compiler error from gcc version
  449.    "2.9-gnupro-99r1" under "-O2 -mcpu=ev6", apparently relating to char
  450.    values being spilled into floating point registers.  The problem doesn't
  451.    show up all the time, but has occurred enough in GMP for us to reject
  452.    this compiler+flags.  */
  453. #include <string.h>  /* for memcpy */
  454. struct try_t
  455. {
  456.  char dst[2];
  457.  char size;
  458.  long d0, d1, d2, d3, d4, d5, d6;
  459.  char overlap;
  460. };
  461. struct try_t param[6];
  462. int
  463. param_init ()
  464. {
  465.  struct try_t *p;
  466.  memcpy (p, &param[ 2 ], sizeof (*p));
  467.  memcpy (p, &param[ 2 ], sizeof (*p));
  468.  p->size = 2;
  469.  memcpy (p, &param[ 1 ], sizeof (*p));
  470.  p->dst[0] = 1;
  471.  p->overlap = 2;
  472.  memcpy (p, &param[ 3 ], sizeof (*p));
  473.  p->dst[0] = 1;
  474.  p->overlap = 8;
  475.  memcpy (p, &param[ 4 ], sizeof (*p));
  476.  memcpy (p, &param[ 4 ], sizeof (*p));
  477.  p->overlap = 8;
  478.  memcpy (p, &param[ 5 ], sizeof (*p));
  479.  memcpy (p, &param[ 5 ], sizeof (*p));
  480.  memcpy (p, &param[ 5 ], sizeof (*p));
  481.  return 0;
  482. }
  483. ])
  484. # __builtin_alloca is not available everywhere, check it exists before
  485. # seeing that it works
  486. GMP_PROG_CC_WORKS_PART_TEST([$1],[__builtin_alloca availability],
  487. [int k; int foo () { __builtin_alloca (k); }],
  488.   [GMP_PROG_CC_WORKS_PART([$1], [alloca array],
  489. [/* The following provokes an internal compiler error from Itanium HP-UX cc
  490.     under +O2 or higher.  We use this sort of code in mpn/generic/mul_fft.c. */
  491. int k;
  492. int foo ()
  493. {
  494.   int i, **a;
  495.   a = __builtin_alloca (k);
  496.   for (i = 0; i <= k; i++)
  497.     a[i] = __builtin_alloca (1 << i);
  498. }
  499. ])])
  500. GMP_PROG_CC_WORKS_PART([$1], [abs int -> double conversion],
  501. [/* The following provokes an internal error from the assembler on
  502.    power2-ibm-aix4.3.1.0.  gcc -mrios2 compiles to nabs+fcirz, and this
  503.    results in "Internal error related to the source program domain".
  504.    For reference it seems to be the combination of nabs+fcirz which is bad,
  505.    not either alone.  This sort of thing occurs in mpz/get_str.c with the
  506.    way double chars_per_bit_exactly is applied in MPN_SIZEINBASE.  Perhaps
  507.    if that code changes to a scaled-integer style then we won't need this
  508.    test.  */
  509. double fp[1];
  510. int x;
  511. int f ()
  512. {
  513.   int a;
  514.   a = (x >= 0 ? x : -x);
  515.   return a * fp[0];
  516. }
  517. ])
  518. GMP_PROG_CC_WORKS_PART([$1], [long long reliability test 1],
  519. [/* The following provokes a segfault in the compiler on powerpc-apple-darwin.
  520.    Extracted from tests/mpn/t-iord_u.c.  Causes Apple's gcc 3.3 build 1640 and
  521.    1666 to segfault with e.g., -O2 -mpowerpc64.  */
  522. #if defined (__GNUC__) && ! defined (__cplusplus)
  523. typedef unsigned long long t1;typedef t1*t2;
  524. static __inline__ t1 e(t2 rp,t2 up,int n,t1 v0)
  525. {t1 c,x,r;int i;if(v0){c=1;for(i=1;i<n;i++){x=up[i];r=x+1;rp[i]=r;}}return c;}
  526. f(){static const struct{t1 n;t1 src[9];t1 want[9];}d[]={{1,{0},{1}},};t1 got[9];int i;
  527. for(i=0;i<1;i++){if(e(got,got,9,d[i].n)==0)h();g(i,d[i].src,d[i].n,got,d[i].want,9);if(d[i].n)h();}}
  528. h(){}g(){}
  529. #else
  530. int dummy;
  531. #endif
  532. ])
  533. GMP_PROG_CC_WORKS_PART([$1], [long long reliability test 2],
  534. [/* The following provokes an internal compiler error on powerpc-apple-darwin.
  535.    Extracted from mpz/cfdiv_q_2exp.c.  Causes Apple's gcc 3.3 build 1640 and
  536.    1666 to get an ICE with -O1 -mpowerpc64.  */
  537. #if defined (__GNUC__) && ! defined (__cplusplus)
  538. f(int u){int i;long long x;x=u?~0:0;if(x)for(i=0;i<9;i++);x&=g();if(x)g();}
  539. g(){}
  540. #else
  541. int dummy;
  542. #endif
  543. ])
  544. GMP_PROG_CC_WORKS_PART_MAIN([$1], [mpn_lshift_com optimization],
  545. [/* The following is mis-compiled by HP ia-64 cc version
  546.         cc: HP aC++/ANSI C B3910B A.05.55 [Dec 04 2003]
  547.    under "cc +O3", both in +DD32 and +DD64 modes.  The mpn_lshift_com gets
  548.    inlined and its return value somehow botched to be 0 instead of 1.  This
  549.    arises in the real mpn_lshift_com in mul_fft.c.  A lower optimization
  550.    level, like +O2 seems ok.  This code needs to be run to show the problem,
  551.    but that's fine, the offending cc is a native-only compiler so we don't
  552.    have to worry about cross compiling.  */
  553. #if ! defined (__cplusplus)
  554. unsigned long
  555. lshift_com (rp, up, n, cnt)
  556.   unsigned long *rp;
  557.   unsigned long *up;
  558.   long n;
  559.   unsigned cnt;
  560. {
  561.   unsigned long retval, high_limb, low_limb;
  562.   unsigned tnc;
  563.   long i;
  564.   tnc = 8 * sizeof (unsigned long) - cnt;
  565.   low_limb = *up++;
  566.   retval = low_limb >> tnc;
  567.   high_limb = low_limb << cnt;
  568.   for (i = n - 1; i != 0; i--)
  569.     {
  570.       low_limb = *up++;
  571.       *rp++ = ~(high_limb | (low_limb >> tnc));
  572.       high_limb = low_limb << cnt;
  573.     }
  574.   return retval;
  575. }
  576. int
  577. main ()
  578. {
  579.   unsigned long cy, rp[2], up[2];
  580.   up[0] = ~ 0L;
  581.   up[1] = 0;
  582.   cy = lshift_com (rp, up, 2L, 1);
  583.   if (cy != 1L)
  584.     return 1;
  585.   return 0;
  586. }
  587. #else
  588. int
  589. main ()
  590. {
  591.   return 0;
  592. }
  593. #endif
  594. ])
  595. GMP_PROG_CC_WORKS_PART_MAIN([$1], [mpn_lshift_com optimization 2],
  596. [/* The following is mis-compiled by Intel ia-64 icc version 1.8 under
  597.     "icc -O3",  After several calls, the function writes parial garbage to
  598.     the result vector.  Perhaps relates to the chk.a.nc insn.  This code needs
  599.     to be run to show the problem, but that's fine, the offending cc is a
  600.     native-only compiler so we don't have to worry about cross compiling.  */
  601. #if ! defined (__cplusplus)
  602. #include <stdlib.h>
  603. void
  604. lshift_com (rp, up, n, cnt)
  605.   unsigned long *rp;
  606.   unsigned long *up;
  607.   long n;
  608.   unsigned cnt;
  609. {
  610.   unsigned long high_limb, low_limb;
  611.   unsigned tnc;
  612.   long i;
  613.   up += n;
  614.   rp += n;
  615.   tnc = 8 * sizeof (unsigned long) - cnt;
  616.   low_limb = *--up;
  617.   high_limb = low_limb << cnt;
  618.   for (i = n - 1; i != 0; i--)
  619.     {
  620.       low_limb = *--up;
  621.       *--rp = ~(high_limb | (low_limb >> tnc));
  622.       high_limb = low_limb << cnt;
  623.     }
  624.   *--rp = ~high_limb;
  625. }
  626. int
  627. main ()
  628. {
  629.   unsigned long *r, *r2;
  630.   unsigned long a[88 + 1];
  631.   long i;
  632.   for (i = 0; i < 88 + 1; i++)
  633.     a[i] = ~0L;
  634.   r = malloc (10000 * sizeof (unsigned long));
  635.   r2 = r;
  636.   for (i = 0; i < 528; i += 22)
  637.     {
  638.       lshift_com (r2, a,
  639.   i / (8 * sizeof (unsigned long)) + 1,
  640.   i % (8 * sizeof (unsigned long)));
  641.       r2 += 88 + 1;
  642.     }
  643.   if (r[2048] != 0 || r[2049] != 0 || r[2050] != 0 || r[2051] != 0 ||
  644.       r[2052] != 0 || r[2053] != 0 || r[2054] != 0)
  645.     abort ();
  646.   return 0;
  647. }
  648. #else
  649. int
  650. main ()
  651. {
  652.   return 0;
  653. }
  654. #endif
  655. ])
  656. # A certain _GLOBAL_OFFSET_TABLE_ problem in past versions of gas, tickled
  657. # by recent versions of gcc.
  658. #
  659. if test "$gmp_prog_cc_works" = yes; then
  660.   case $host in
  661.     X86_PATTERN)
  662.       # this problem only arises in PIC code, so don't need to test when
  663.       # --disable-shared.  We don't necessarily have $enable_shared set to
  664.       # yes at this point, it will still be unset for the default (which is
  665.       # yes); hence the use of "!= no".
  666.       if test "$enable_shared" != no; then
  667.         GMP_PROG_CC_X86_GOT_EAX_EMITTED([$1],
  668.           [GMP_ASM_X86_GOT_EAX_OK([$1],,
  669.             [gmp_prog_cc_works="no, bad gas GOT with eax"])])
  670.       fi
  671.       ;;
  672.   esac
  673. fi
  674. AC_MSG_RESULT($gmp_prog_cc_works)
  675. case $gmp_prog_cc_works in
  676.   yes)
  677.     [$2]
  678.     ;;
  679.   *)
  680.     [$3]
  681.     ;;
  682. esac
  683. ])
  684. dnl  Called: GMP_PROG_CC_WORKS_PART(CC+CFLAGS,FAIL-MESSAGE [,CODE])
  685. dnl  A dummy main() is appended to the CODE given.
  686. dnl
  687. AC_DEFUN([GMP_PROG_CC_WORKS_PART],
  688. [GMP_PROG_CC_WORKS_PART_MAIN([$1],[$2],
  689. [$3]
  690. [int main () { return 0; }])
  691. ])
  692. dnl  Called: GMP_PROG_CC_WORKS_PART_MAIN(CC+CFLAGS,FAIL-MESSAGE,CODE)
  693. dnl  CODE must include a main().
  694. dnl
  695. AC_DEFUN([GMP_PROG_CC_WORKS_PART_MAIN],
  696. [GMP_PROG_CC_WORKS_PART_TEST([$1],[$2],[$3],
  697.   [],
  698.   gmp_prog_cc_works="no[]m4_if([$2],,,[[, ]])[$2]",
  699.   gmp_prog_cc_works="no[]m4_if([$2],,,[[, ]])[$2][[, program does not run]]")
  700. ])
  701. dnl  Called: GMP_PROG_CC_WORKS_PART_TEST(CC+CFLAGS,TITLE,[CODE],
  702. dnl            [ACTION-GOOD],[ACTION-BAD][ACTION-NORUN])
  703. dnl
  704. AC_DEFUN([GMP_PROG_CC_WORKS_PART_TEST],
  705. [if test "$gmp_prog_cc_works" = yes; then
  706.   # remove anything that might look like compiler output to our "||" expression
  707.   rm -f conftest* a.out b.out a.exe a_out.exe
  708.   cat >conftest.c <<EOF
  709. [$3]
  710. EOF
  711.   echo "Test compile: [$2]" >&AC_FD_CC
  712.   gmp_compile="$1 conftest.c >&AC_FD_CC"
  713.   if AC_TRY_EVAL(gmp_compile); then
  714.     cc_works_part=yes
  715.     if test "$cross_compiling" = no; then
  716.       if AC_TRY_COMMAND([./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest]); then :;
  717.       else
  718.         cc_works_part=norun
  719.       fi
  720.     fi
  721.   else
  722.     cc_works_part=no
  723.   fi
  724.   if test "$cc_works_part" != yes; then
  725.     echo "failed program was:" >&AC_FD_CC
  726.     cat conftest.c >&AC_FD_CC
  727.   fi
  728.   rm -f conftest* a.out b.out a.exe a_out.exe
  729.   case $cc_works_part in
  730.     yes)
  731.       $4
  732.       ;;
  733.     no)
  734.       $5
  735.       ;;
  736.     norun)
  737.       $6
  738.       ;;
  739.   esac
  740. fi
  741. ])
  742. dnl  GMP_PROG_CC_WORKS_LONGLONG(cc+cflags,[ACTION-YES][,ACTION-NO])
  743. dnl  --------------------------------------------------------------
  744. dnl  Check that cc+cflags accepts "long long".
  745. dnl
  746. dnl  This test is designed to be run repeatedly with different cc+cflags
  747. dnl  selections, so the result is not cached.
  748. AC_DEFUN([GMP_PROG_CC_WORKS_LONGLONG],
  749. [AC_MSG_CHECKING([compiler $1 has long long])
  750. cat >conftest.c <<EOF
  751. long long  foo;
  752. long long  bar () { return foo; }
  753. int main () { return 0; }
  754. EOF
  755. gmp_prog_cc_works=no
  756. gmp_compile="$1 -c conftest.c >&AC_FD_CC"
  757. if AC_TRY_EVAL(gmp_compile); then
  758.   gmp_prog_cc_works=yes
  759. else
  760.   echo "failed program was:" >&AC_FD_CC
  761.   cat conftest.c >&AC_FD_CC
  762. fi
  763. rm -f conftest* a.out b.out a.exe a_out.exe
  764. AC_MSG_RESULT($gmp_prog_cc_works)
  765. if test $gmp_prog_cc_works = yes; then
  766.   ifelse([$2],,:,[$2])
  767. else
  768.   ifelse([$3],,:,[$3])
  769. fi
  770. ])
  771. dnl  GMP_C_TEST_SIZEOF(cc/cflags,test,[ACTION-GOOD][,ACTION-BAD])
  772. dnl  ------------------------------------------------------------
  773. dnl  The given cc/cflags compiler is run to check the size of a type
  774. dnl  specified by the "test" argument.  "test" can either be a string, or a
  775. dnl  variable like $foo.  The value should be for instance "sizeof-long-4",
  776. dnl  to test that sizeof(long)==4.
  777. dnl
  778. dnl  This test is designed to be run for different compiler and/or flags
  779. dnl  combinations, so the result is not cached.
  780. dnl
  781. dnl  The idea for making an array that has a negative size if the desired
  782. dnl  condition test is false comes from autoconf AC_CHECK_SIZEOF.  The cast
  783. dnl  to "long" in the array dimension also follows autoconf, apparently it's
  784. dnl  a workaround for a HP compiler bug.
  785. AC_DEFUN([GMP_C_TEST_SIZEOF],
  786. [echo "configure: testlist $2" >&AC_FD_CC
  787. [gmp_sizeof_type=`echo "$2" | sed 's/sizeof-([a-z]*).*/1/'`]
  788. [gmp_sizeof_want=`echo "$2" | sed 's/sizeof-[a-z]*-([0-9]*).*/1/'`]
  789. AC_MSG_CHECKING([compiler $1 has sizeof($gmp_sizeof_type)==$gmp_sizeof_want])
  790. cat >conftest.c <<EOF
  791. [int
  792. main ()
  793. {
  794.   static int test_array [1 - 2 * (long) (sizeof ($gmp_sizeof_type) != $gmp_sizeof_want)];
  795.   test_array[0] = 0;
  796.   return 0;
  797. }]
  798. EOF
  799. gmp_c_testlist_sizeof=no
  800. gmp_compile="$1 -c conftest.c >&AC_FD_CC"
  801. if AC_TRY_EVAL(gmp_compile); then
  802.   gmp_c_testlist_sizeof=yes
  803. fi
  804. rm -f conftest*
  805. AC_MSG_RESULT($gmp_c_testlist_sizeof)
  806. if test $gmp_c_testlist_sizeof = yes; then
  807.   ifelse([$3],,:,[$3])
  808. else
  809.   ifelse([$4],,:,[$4])
  810. fi
  811. ])
  812. dnl  GMP_PROG_CC_IS_GNU(CC,[ACTIONS-IF-YES][,ACTIONS-IF-NO])
  813. dnl  -------------------------------------------------------
  814. dnl  Determine whether the given compiler is GNU C.
  815. dnl
  816. dnl  This test is the same as autoconf _AC_LANG_COMPILER_GNU, but doesn't
  817. dnl  cache the result.  The same "ifndef" style test is used, to avoid
  818. dnl  problems with syntax checking cpp's used on NeXT and Apple systems.
  819. AC_DEFUN([GMP_PROG_CC_IS_GNU],
  820. [cat >conftest.c <<EOF
  821. #if ! defined (__GNUC__) || defined (__INTEL_COMPILER)
  822.   choke me
  823. #endif
  824. EOF
  825. gmp_compile="$1 -c conftest.c >&AC_FD_CC"
  826. if AC_TRY_EVAL(gmp_compile); then
  827.   rm -f conftest*
  828.   AC_MSG_CHECKING([whether $1 is gcc])
  829.   AC_MSG_RESULT(yes)
  830.   ifelse([$2],,:,[$2])
  831. else
  832.   rm -f conftest*
  833.   ifelse([$3],,:,[$3])
  834. fi
  835. ])
  836. dnl  GMP_PROG_CC_IS_XLC(CC,[ACTIONS-IF-YES][,ACTIONS-IF-NO])
  837. dnl  -------------------------------------------------------
  838. dnl  Determine whether the given compiler is IBM xlc (on AIX).
  839. dnl
  840. dnl  There doesn't seem to be a preprocessor symbol to test for this, or if
  841. dnl  there is one then it's well hidden in xlc 3.1 on AIX 4.3, so just grep
  842. dnl  the man page printed when xlc is invoked with no arguments.
  843. AC_DEFUN([GMP_PROG_CC_IS_XLC],
  844. [gmp_command="$1 2>&1 | grep xlc >/dev/null"
  845. if AC_TRY_EVAL(gmp_command); then
  846.   AC_MSG_CHECKING([whether $1 is xlc])
  847.   AC_MSG_RESULT(yes)
  848.   ifelse([$2],,:,[$2])
  849. else
  850.   ifelse([$3],,:,[$3])
  851. fi
  852. ])
  853. dnl  GMP_PROG_CC_X86_GOT_EAX_EMITTED(CC+CFLAGS, [ACTION-YES] [, ACTION-NO])
  854. dnl  ----------------------------------------------------------------------
  855. dnl  Determine whether CC+CFLAGS emits instructions using %eax with
  856. dnl  _GLOBAL_OFFSET_TABLE_.  This test is for use on x86 systems.
  857. dnl
  858. dnl  Recent versions of gcc will use %eax for the GOT in leaf functions, for
  859. dnl  instance gcc 3.3.3 with -O3.  This avoids having to save and restore
  860. dnl  %ebx which otherwise usually holds the GOT, and is what gcc used in the
  861. dnl  past.
  862. dnl
  863. dnl  %ecx and %edx are also candidates for this sort of optimization, and
  864. dnl  are used under lesser optimization levels, like -O2 in 3.3.3.  FIXME:
  865. dnl  It's not quite clear what the conditions for using %eax are, we might
  866. dnl  need more test code to provoke it.
  867. dnl
  868. dnl  The motivation for this test is that past versions of gas have bugs
  869. dnl  affecting this usage, see GMP_ASM_X86_GOT_EAX_OK.
  870. dnl
  871. dnl  This test is not specific to gcc, other compilers might emit %eax GOT
  872. dnl  insns like this, though we've not investigated that.
  873. dnl
  874. dnl  This is for use by compiler probing in GMP_PROG_CC_WORKS, so we doesn't
  875. dnl  cache the result.
  876. dnl
  877. dnl  -fPIC is hard coded here, because this test is for use before libtool
  878. dnl  has established the pic options.  It's right for gcc, but perhaps not
  879. dnl  other compilers.
  880. AC_DEFUN([GMP_PROG_CC_X86_GOT_EAX_EMITTED],
  881. [echo "Testing gcc GOT with eax emitted" >&AC_FD_CC
  882. cat >conftest.c <<EOF
  883. [int foo;
  884. int bar () { return foo; }
  885. ]EOF
  886. tmp_got_emitted=no
  887. gmp_compile="$1 -fPIC -S conftest.c >&AC_FD_CC 2>&1"
  888. if AC_TRY_EVAL(gmp_compile); then
  889.   if grep "addl.*_GLOBAL_OFFSET_TABLE_.*eax" conftest.s >/dev/null; then
  890.     tmp_got_emitted=yes
  891.   fi
  892. fi
  893. rm -f conftest.*
  894. echo "Result: $tmp_got_emitted" >&AC_FD_CC
  895. if test "$tmp_got_emitted" = yes; then
  896.   ifelse([$2],,:,[$2])
  897. else
  898.   ifelse([$3],,:,[$3])
  899. fi
  900. ])
  901. dnl  GMP_HPC_HPPA_2_0(cc,[ACTION-IF-GOOD][,ACTION-IF-BAD])
  902. dnl  ---------------------------------------------------------
  903. dnl  Find out whether a HP compiler is good enough to generate hppa 2.0.
  904. dnl
  905. dnl  This test might be repeated for different compilers, so the result is
  906. dnl  not cached.
  907. AC_DEFUN([GMP_HPC_HPPA_2_0],
  908. [AC_MSG_CHECKING([whether HP compiler $1 is good for 64-bits])
  909. # Bad compiler output:
  910. #   ccom: HP92453-01 G.10.32.05 HP C Compiler
  911. # Good compiler output:
  912. #   ccom: HP92453-01 A.10.32.30 HP C Compiler
  913. # Let A.10.32.30 or higher be ok.
  914. echo >conftest.c
  915. gmp_tmp_vs=`$1 $2 -V -c -o conftest.$OBJEXT conftest.c 2>&1 | grep "^ccom:"`
  916. echo "Version string: $gmp_tmp_vs" >&AC_FD_CC
  917. rm conftest*
  918. gmp_tmp_v1=`echo $gmp_tmp_vs | sed 's/.* ..([[0-9]]*).*/1/'`
  919. gmp_tmp_v2=`echo $gmp_tmp_vs | sed 's/.* ...*.(.*)..* HP C.*/1/'`
  920. gmp_tmp_v3=`echo $gmp_tmp_vs | sed 's/.* ...*..*.(.*) HP C.*/1/'`
  921. echo "Version number: $gmp_tmp_v1.$gmp_tmp_v2.$gmp_tmp_v3" >&AC_FD_CC
  922. if test -z "$gmp_tmp_v1"; then
  923.   gmp_hpc_64bit=not-applicable
  924. else
  925.   GMP_COMPARE_GE($gmp_tmp_v1, 10, $gmp_tmp_v2, 32, $gmp_tmp_v3, 30)
  926.   gmp_hpc_64bit=$gmp_compare_ge
  927. fi
  928. AC_MSG_RESULT($gmp_hpc_64bit)
  929. if test $gmp_hpc_64bit = yes; then
  930.   ifelse([$2],,:,[$2])
  931. else
  932.   ifelse([$3],,:,[$3])
  933. fi
  934. ])
  935. dnl  GMP_GCC_ARM_UMODSI(CC,[ACTIONS-IF-GOOD][,ACTIONS-IF-BAD])
  936. dnl  ---------------------------------------------------------
  937. dnl  gcc 2.95.3 and earlier on arm has a bug in the libgcc __umodsi routine
  938. dnl  making "%" give wrong results for some operands, eg. "0x90000000 % 3".
  939. dnl  We're hoping it'll be fixed in 2.95.4, and we know it'll be fixed in
  940. dnl  gcc 3.
  941. dnl
  942. dnl  There's only a couple of places gmp cares about this, one is the
  943. dnl  size==1 case in mpn/generic/mode1o.c, and this shows up in
  944. dnl  tests/mpz/t-jac.c as a wrong result from mpz_kronecker_ui.
  945. AC_DEFUN([GMP_GCC_ARM_UMODSI],
  946. [AC_MSG_CHECKING([whether ARM gcc unsigned division works])
  947. tmp_version=`$1 --version`
  948. echo "$tmp_version" >&AC_FD_CC
  949. case $tmp_version in
  950.   [2.95 | 2.95.[123]])
  951.     ifelse([$3],,:,[$3])
  952.     gmp_gcc_arm_umodsi_result=["no, gcc 2.95.[0123]"] ;;
  953.   *)
  954.     ifelse([$2],,:,[$2])
  955.     gmp_gcc_arm_umodsi_result=yes ;;
  956. esac
  957. AC_MSG_RESULT([$gmp_gcc_arm_umodsi_result])
  958. ])
  959. dnl  GMP_GCC_MIPS_O32(gcc,[actions-yes][,[actions-no]])
  960. dnl  -------------------------------------------------
  961. dnl  Test whether gcc supports o32.
  962. dnl
  963. dnl  gcc 2.7.2.2 only does o32, and doesn't accept -mabi=32.
  964. dnl
  965. dnl  gcc 2.95 accepts -mabi=32 but it only works on irix5, on irix6 it gives
  966. dnl  "cc1: The -mabi=32 support does not work yet".
  967. AC_DEFUN([GMP_GCC_MIPS_O32],
  968. [AC_MSG_CHECKING([whether gcc supports o32])
  969. echo 'int x;' >conftest.c
  970. echo "$1 -mabi=32 -c conftest.c" >&AC_FD_CC
  971. if $1 -mabi=32 -c conftest.c >conftest.out 2>&1; then
  972.   result=yes
  973. else
  974.   cat conftest.out >&AC_FD_CC
  975.   if grep "cc1: Invalid option `abi=32'" conftest.out >/dev/null; then
  976.     result=yes
  977.   else
  978.     result=no
  979.   fi
  980. fi
  981. rm -f conftest.*
  982. AC_MSG_RESULT($result)
  983. if test $result = yes; then
  984.   ifelse([$2],,:,[$2])
  985. else
  986.   ifelse([$3],,:,[$3])
  987. fi
  988. ])
  989. dnl  GMP_GCC_NO_CPP_PRECOMP(CCBASE,CC,CFLAGS,[ACTIONS-YES][,ACTIONS-NO])
  990. dnl  -------------------------------------------------------------------
  991. dnl  Check whether -no-cpp-precomp should be used on this compiler, and
  992. dnl  execute the corresponding ACTIONS-YES or ACTIONS-NO.
  993. dnl
  994. dnl  -no-cpp-precomp is only meant for Apple's hacked version of gcc found
  995. dnl  on powerpc*-*-darwin*, but we can give it a try on any gcc.  Normal gcc
  996. dnl  (as of 3.0 at least) only gives a warning, not an actual error, and we
  997. dnl  watch for that and decide against the option in that case, to avoid
  998. dnl  confusing the user.
  999. AC_DEFUN([GMP_GCC_NO_CPP_PRECOMP],
  1000. [if test "$ccbase" = gcc; then
  1001.   AC_MSG_CHECKING([compiler $2 $3 -no-cpp-precomp])
  1002.   result=no
  1003.   cat >conftest.c <<EOF
  1004. int main () { return 0; }
  1005. EOF
  1006.   gmp_compile="$2 $3 -no-cpp-precomp conftest.c >conftest.out 2>&1"
  1007.   if AC_TRY_EVAL(gmp_compile); then
  1008.     if grep "unrecognized option.*-no-cpp-precomp" conftest.out >/dev/null; then : ;
  1009.     else
  1010.       result=yes
  1011.     fi
  1012.   fi
  1013.   cat conftest.out >&AC_FD_CC
  1014.   rm -f conftest* a.out b.out a.exe a_out.exe
  1015.   AC_MSG_RESULT($result)
  1016.   if test "$result" = yes; then
  1017.       ifelse([$4],,:,[$4])
  1018.   else
  1019.       ifelse([$5],,:,[$5])
  1020.   fi
  1021. fi
  1022. ])
  1023. dnl  GMP_GCC_PENTIUM4_SSE2(CC+CFLAGS,[ACTION-IF-YES][,ACTION-IF-NO])
  1024. dnl  ---------------------------------------------------------------
  1025. dnl  Determine whether gcc CC+CFLAGS is a good enough version for
  1026. dnl  -march=pentium4 with sse2.
  1027. dnl
  1028. dnl  Gcc 3.2.1 was seen generating incorrect code for raw double -> int
  1029. dnl  conversions through a union.  We believe the problem is in all 3.1 and
  1030. dnl  3.2 versions, but that it's fixed in 3.3.
  1031. AC_DEFUN([GMP_GCC_PENTIUM4_SSE2],
  1032. [AC_MSG_CHECKING([whether gcc is good for sse2])
  1033. case `$1 -dumpversion` in
  1034.   [3.[012] | 3.[012].*]) result=no ;;
  1035.   *)                     result=yes ;;
  1036. esac
  1037. AC_MSG_RESULT($result)
  1038. if test "$result" = yes; then
  1039.   ifelse([$2],,:,[$2])
  1040. else
  1041.   ifelse([$3],,:,[$3])
  1042. fi
  1043. ])
  1044. dnl  GMP_GCC_WA_MCPU(CC+CFLAGS, NEWFLAG [,ACTION-YES [,ACTION-NO]])
  1045. dnl  --------------------------------------------------------------
  1046. dnl  Check whether gcc (or gas rather) accepts a flag like "-Wa,-mev67".
  1047. dnl
  1048. dnl  Gas doesn't give an error for an unknown cpu, it only prints a warning
  1049. dnl  like "Warning: Unknown CPU identifier `ev78'".
  1050. dnl
  1051. dnl  This is intended for use on alpha, since only recent versions of gas
  1052. dnl  accept -mev67, but there's nothing here that's alpha specific.
  1053. AC_DEFUN([GMP_GCC_WA_MCPU],
  1054. [AC_MSG_CHECKING([assembler $1 $2])
  1055. result=no
  1056. cat >conftest.c <<EOF
  1057. int main () {}
  1058. EOF
  1059. gmp_compile="$1 $2 -c conftest.c >conftest.out 2>&1"
  1060. if AC_TRY_EVAL(gmp_compile); then
  1061.   if grep "Unknown CPU identifier" conftest.out >/dev/null; then : ;
  1062.   else
  1063.     result=yes
  1064.   fi
  1065. fi
  1066. cat conftest.out >&AC_FD_CC
  1067. rm -f conftest*
  1068. AC_MSG_RESULT($result)
  1069. if test "$result" = yes; then
  1070.   ifelse([$3],,:,[$3])
  1071. else
  1072.   ifelse([$4],,:,[$4])
  1073. fi
  1074. ])
  1075. dnl  GMP_GCC_WA_OLDAS(CC+CFLAGS [,ACTION-YES [,ACTION-NO]])
  1076. dnl  ------------------------------------------------------
  1077. dnl  Check whether gcc should be run with "-Wa,-oldas".
  1078. dnl
  1079. dnl  On systems alpha*-*-osf* (or maybe just osf5), apparently there's a
  1080. dnl  newish Compaq "as" which doesn't work with the gcc mips-tfile.
  1081. dnl  Compiling an empty file with "gcc -c foo.c" produces for instance
  1082. dnl
  1083. dnl      mips-tfile, /tmp/ccaqUNnF.s:7 Segmentation fault
  1084. dnl
  1085. dnl  The fix is to pass "-oldas" to that assembler, as noted by
  1086. dnl
  1087. dnl      http://gcc.gnu.org/install/specific.html#alpha*-dec-osf*
  1088. dnl
  1089. dnl  The test here tries to compile an empty file, and if that fails but
  1090. dnl  adding -Wa,-oldas makes it succeed, then that flag is considered
  1091. dnl  necessary.
  1092. dnl
  1093. dnl  We look for the failing case specifically, since it may not be a good
  1094. dnl  idea to use -Wa,-oldas in other circumstances.  For instance gas takes
  1095. dnl  "-oldas" to mean the "-o" option and will write a file called "ldas" as
  1096. dnl  its output.  Normally gcc puts its own "-o" after any -Wa options, so
  1097. dnl  -oldas ends up being harmless, but clearly that's only through good
  1098. dnl  luck.
  1099. dnl
  1100. dnl  This macro is designed for use while probing for a good compiler, and
  1101. dnl  so doesn't cache it's result.
  1102. AC_DEFUN([GMP_GCC_WA_OLDAS],
  1103. [AC_MSG_CHECKING([for $1 -Wa,-oldas])
  1104. result=no
  1105. cat >conftest.c <<EOF
  1106. EOF
  1107. echo "with empty conftest.c" >&AC_FD_CC
  1108. gmp_compile="$1 -c conftest.c >&AC_FD_CC 2>&1"
  1109. if AC_TRY_EVAL(gmp_compile); then : ;
  1110. else
  1111.   # empty fails
  1112.   gmp_compile="$1 -Wa,-oldas -c conftest.c >&AC_FD_CC 2>&1"
  1113.   if AC_TRY_EVAL(gmp_compile); then
  1114.     # but with -Wa,-oldas it works
  1115.     result=yes
  1116.   fi
  1117. fi
  1118. rm -f conftest*
  1119. AC_MSG_RESULT($result)
  1120. if test "$result" = yes; then
  1121.   ifelse([$2],,:,[$2])
  1122. else
  1123.   ifelse([$3],,:,[$3])
  1124. fi
  1125. ])
  1126. dnl  GMP_OS_X86_XMM(CC+CFLAGS,[ACTION-IF-YES][,ACTION-IF-NO])
  1127. dnl  --------------------------------------------------------
  1128. dnl  Determine whether the operating system supports XMM registers.
  1129. dnl
  1130. dnl  If build==host then a test program is run, executing an SSE2
  1131. dnl  instruction using an XMM register.  This will give a SIGILL if the
  1132. dnl  system hasn't set the OSFXSR bit in CR4 to say it knows it must use
  1133. dnl  fxsave/fxrestor in a context switch (to save xmm registers).
  1134. dnl
  1135. dnl  If build!=host, we can fallback on:
  1136. dnl
  1137. dnl      - FreeBSD version 4 is the first supporting xmm.
  1138. dnl
  1139. dnl      - Linux kernel 2.4 might be the first stable series supporting xmm
  1140. dnl        (not sure).  But there's no version number in the GNU/Linux
  1141. dnl        config tuple to test anyway.
  1142. dnl
  1143. dnl  The default is to allow xmm.  This might seem rash, but it's likely
  1144. dnl  most systems know xmm by now, so this will normally be what's wanted.
  1145. dnl  And cross compiling is a bit hairy anyway, so hopefully anyone doing it
  1146. dnl  will be smart enough to know what to do.
  1147. dnl
  1148. dnl  In the test program, .text and .globl are hard coded because this macro
  1149. dnl  is wanted before GMP_ASM_TEXT and GMP_ASM_GLOBL are run.  A .byte
  1150. dnl  sequence is used (for xorps %xmm0, %xmm0) to make us independent of
  1151. dnl  tests for whether the assembler supports sse2/xmm.  Obviously we need
  1152. dnl  both assembler and OS support, but this means we don't force the order
  1153. dnl  in which we test.
  1154. dnl
  1155. dnl  FIXME: Maybe we should use $CCAS to assemble, if it's set.  (Would
  1156. dnl  still want $CC/$CFLAGS for the link.)  But this test is used before
  1157. dnl  AC_PROG_CC sets $OBJEXT, so we'd need to check for various object file
  1158. dnl  suffixes ourselves.
  1159. AC_DEFUN([GMP_OS_X86_XMM],
  1160. [AC_CACHE_CHECK([whether the operating system supports XMM registers],
  1161. gmp_cv_os_x86_xmm,
  1162. [if test "$build" = "$host"; then
  1163.   # remove anything that might look like compiler output to our "||" expression
  1164.   rm -f conftest* a.out b.out a.exe a_out.exe
  1165.   cat >conftest.s <<EOF
  1166. .text
  1167. main:
  1168. _main:
  1169. .globl main
  1170. .globl _main
  1171. .byte 0x0f, 0x57, 0xc0
  1172. xorl %eax, %eax
  1173. ret
  1174. EOF
  1175.   gmp_compile="$1 conftest.s -o conftest >&AC_FD_CC"
  1176.   if AC_TRY_EVAL(gmp_compile); then
  1177.     if AC_TRY_COMMAND([./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest]); then
  1178.       gmp_cv_os_x86_xmm=yes
  1179.     else
  1180.       gmp_cv_os_x86_xmm=no
  1181.     fi
  1182.   else
  1183.     AC_MSG_WARN([Oops, cannot compile test program])
  1184.   fi
  1185.   rm -f conftest*
  1186. fi
  1187. if test -z "$gmp_cv_os_x86_xmm"; then
  1188.   case $host_os in
  1189.     [freebsd[123] | freebsd[123].*])
  1190.       gmp_cv_os_x86_xmm=no ;;
  1191.     freebsd*)
  1192.       gmp_cv_os_x86_xmm=yes ;;
  1193.     *)
  1194.       gmp_cv_os_x86_xmm=probably ;;
  1195.   esac
  1196. fi
  1197. ])
  1198. if test "$gmp_cv_os_x86_xmm" = probably; then
  1199.   AC_MSG_WARN([Not certain of OS support for xmm when cross compiling.])
  1200.   AC_MSG_WARN([Will assume it's ok, expect a SIGILL if this is wrong.])
  1201. fi
  1202. case $gmp_cv_os_x86_xmm in
  1203. no)
  1204.   $3
  1205.   ;;
  1206. *)
  1207.   $2
  1208.   ;;
  1209. esac
  1210. ])
  1211. dnl  GMP_CRAY_HOST_TYPES(C90/T90-IEEE, C90/T90-CFP, J90/SV1)
  1212. dnl  -------------------------------------------------------
  1213. dnl  Execute the actions in the arguments on the respective Cray vector
  1214. dnl  systems.  For other hosts, do nothing.
  1215. dnl
  1216. dnl  This macro should be used after the C compiler has been chosen, since
  1217. dnl  on c90 and t90 we ask the compiler whether we're in IEEE or CFP float
  1218. dnl  mode.
  1219. dnl
  1220. dnl  This code is in a macro so that any AC_REQUIRE pre-requisites of
  1221. dnl  AC_EGREP_CPP will be expanded at the top-level, ie. for all hosts not
  1222. dnl  merely c90 and t90.  In autoconf 2.57 for instance this means
  1223. dnl  AC_PROG_EGREP, which is needed by various other macros.
  1224. AC_DEFUN([GMP_CRAY_OPTIONS],
  1225. [case $host_cpu in
  1226.   c90 | t90)
  1227.     AC_EGREP_CPP(yes,
  1228. [#ifdef _CRAYIEEE
  1229. yes
  1230. #endif],
  1231.     [$1],
  1232.     [$2])
  1233.     ;;
  1234.   j90 | sv1)
  1235.     [$3]
  1236.     ;;
  1237. esac
  1238. ])
  1239. dnl  GMP_HPPA_LEVEL_20(cc/cflags [, ACTION-GOOD [,ACTION-BAD]])
  1240. dnl  ----------------------------------------------------------
  1241. dnl  Check that the given cc/cflags accepts HPPA 2.0n assembler code.
  1242. dnl
  1243. dnl  Old versions of gas don't know 2.0 instructions.  It rejects ".level
  1244. dnl  2.0" for a start, so just test that.
  1245. dnl
  1246. dnl  This test is designed to be run for various different compiler and
  1247. dnl  flags combinations, and hence doesn't cache its result.
  1248. AC_DEFUN([GMP_HPPA_LEVEL_20],
  1249. [AC_MSG_CHECKING([$1 assembler knows hppa 2.0])
  1250. result=no
  1251. cat >conftest.s <<EOF
  1252. .level 2.0
  1253. EOF
  1254. gmp_compile="$1 -c conftest.s >&AC_FD_CC 2>&1"
  1255. if AC_TRY_EVAL(gmp_compile); then
  1256.   result=yes
  1257. else
  1258.   echo "failed program was" >&AC_FD_CC
  1259.   cat conftest.s >&AC_FD_CC
  1260. fi
  1261. rm -f conftest*
  1262. AC_MSG_RESULT($result)
  1263. if test "$result" = yes; then
  1264.   ifelse([$2],,:,[$2])
  1265. else
  1266.   ifelse([$3],,:,[$3])
  1267. fi
  1268. ])
  1269. dnl  GMP_PROG_CXX_WORKS(cxx/cxxflags [, ACTION-YES [,ACTION-NO]])
  1270. dnl  ------------------------------------------------------------
  1271. dnl  Check whether cxx/cxxflags can compile and link.
  1272. dnl
  1273. dnl  This test is designed to be run repeatedly with different cxx/cxxflags
  1274. dnl  selections, so the result is not cached.
  1275. dnl
  1276. dnl  For a native build, we insist on being able to run the program, so as
  1277. dnl  to detect any problems with the standard C++ library.  During
  1278. dnl  development various systems with broken or incomplete C++ installations
  1279. dnl  were seen.
  1280. dnl
  1281. dnl  The various features and problems we try to detect are done in separate
  1282. dnl  compiles.  Although this is probably a bit slower than one test
  1283. dnl  program, it makes it easy to indicate the problem in AC_MSG_RESULT,
  1284. dnl  hence giving the user a clue about why we rejected the compiler.
  1285. AC_DEFUN([GMP_PROG_CXX_WORKS],
  1286. [AC_MSG_CHECKING([C++ compiler $1])
  1287. gmp_prog_cxx_works=yes
  1288. # start with a plain "main()", then go on to further checks
  1289. GMP_PROG_CXX_WORKS_PART([$1], [])
  1290. GMP_PROG_CXX_WORKS_PART([$1], [namespace],
  1291. [namespace foo { }
  1292. using namespace foo;
  1293. ])
  1294. # GMP requires the standard C++ iostream classes
  1295. GMP_PROG_CXX_WORKS_PART([$1], [std iostream],
  1296. [/* This test rejects g++ 2.7.2 which doesn't have <iostream>, only a
  1297.     pre-standard iostream.h. */
  1298. #include <iostream>
  1299. /* This test rejects OSF 5.1 Compaq C++ in its default pre-standard iostream
  1300.    mode, since that mode puts cout in the global namespace, not "std".  */
  1301. void someoutput (void) { std::cout << 123; }
  1302. ])
  1303. AC_MSG_RESULT($gmp_prog_cxx_works)
  1304. case $gmp_prog_cxx_works in
  1305.   yes)
  1306.     [$2]
  1307.     ;;
  1308.   *)
  1309.     [$3]
  1310.     ;;
  1311. esac
  1312. ])
  1313. dnl  Called: GMP_PROG_CXX_WORKS_PART(CXX+CXXFLAGS, FAIL-MESSAGE [,CODE])
  1314. dnl
  1315. AC_DEFUN([GMP_PROG_CXX_WORKS_PART],
  1316. [if test "$gmp_prog_cxx_works" = yes; then
  1317.   # remove anything that might look like compiler output to our "||" expression
  1318.   rm -f conftest* a.out b.out a.exe a_out.exe
  1319.   cat >conftest.cc <<EOF
  1320. [$3]
  1321. int main (void) { return 0; }
  1322. EOF
  1323.   echo "Test compile: [$2]" >&AC_FD_CC
  1324.   gmp_cxxcompile="$1 conftest.cc >&AC_FD_CC"
  1325.   if AC_TRY_EVAL(gmp_cxxcompile); then
  1326.     if test "$cross_compiling" = no; then
  1327.       if AC_TRY_COMMAND([./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest]); then :;
  1328.       else
  1329.         gmp_prog_cxx_works="no[]m4_if([$2],,,[, ])[$2], program does not run"
  1330.       fi
  1331.     fi
  1332.   else
  1333.     gmp_prog_cxx_works="no[]m4_if([$2],,,[, ])[$2]"
  1334.   fi
  1335.   case $gmp_prog_cxx_works in
  1336.     no*)
  1337.       echo "failed program was:" >&AC_FD_CC
  1338.       cat conftest.cc >&AC_FD_CC
  1339.       ;;
  1340.   esac
  1341.   rm -f conftest* a.out b.out a.exe a_out.exe
  1342. fi
  1343. ])
  1344. dnl  GMP_INIT([M4-DEF-FILE])
  1345. dnl  -----------------------
  1346. dnl  Initializations for GMP config.m4 generation.
  1347. dnl
  1348. dnl  FIXME: The generated config.m4 doesn't get recreated by config.status.
  1349. dnl  Maybe the relevant "echo"s should go through AC_CONFIG_COMMANDS.
  1350. AC_DEFUN([GMP_INIT],
  1351. [ifelse([$1], , gmp_configm4=config.m4, gmp_configm4="[$1]")
  1352. gmp_tmpconfigm4=cnfm4.tmp
  1353. gmp_tmpconfigm4i=cnfm4i.tmp
  1354. gmp_tmpconfigm4p=cnfm4p.tmp
  1355. rm -f $gmp_tmpconfigm4 $gmp_tmpconfigm4i $gmp_tmpconfigm4p
  1356. # CONFIG_TOP_SRCDIR is a path from the mpn builddir to the top srcdir.
  1357. # The pattern here tests for an absolute path the same way as
  1358. # _AC_OUTPUT_FILES in autoconf acgeneral.m4.
  1359. case $srcdir in
  1360. [[\/]]* | ?:[[\/]]* )  tmp="$srcdir"    ;;
  1361. *)                       tmp="../$srcdir" ;;
  1362. esac
  1363. echo ["define(<CONFIG_TOP_SRCDIR>,<`$tmp'>)"] >>$gmp_tmpconfigm4
  1364. # All CPUs use asm-defs.m4
  1365. echo ["include][(CONFIG_TOP_SRCDIR`/mpn/asm-defs.m4')"] >>$gmp_tmpconfigm4i
  1366. ])
  1367. dnl  GMP_FINISH
  1368. dnl  ----------
  1369. dnl  Create config.m4 from its accumulated parts.
  1370. dnl
  1371. dnl  __CONFIG_M4_INCLUDED__ is used so that a second or subsequent include
  1372. dnl  of config.m4 is harmless.
  1373. dnl
  1374. dnl  A separate ifdef on the angle bracket quoted part ensures the quoting
  1375. dnl  style there is respected.  The basic defines from gmp_tmpconfigm4 are
  1376. dnl  fully quoted but are still put under an ifdef in case any have been
  1377. dnl  redefined by one of the m4 include files.
  1378. dnl
  1379. dnl  Doing a big ifdef within asm-defs.m4 and/or other macro files wouldn't
  1380. dnl  work, since it'd interpret parentheses and quotes in dnl comments, and
  1381. dnl  having a whole file as a macro argument would overflow the string space
  1382. dnl  on BSD m4.
  1383. AC_DEFUN([GMP_FINISH],
  1384. [AC_REQUIRE([GMP_INIT])
  1385. echo "creating $gmp_configm4"
  1386. echo ["d""nl $gmp_configm4.  Generated automatically by configure."] > $gmp_configm4
  1387. if test -f $gmp_tmpconfigm4; then
  1388.   echo ["changequote(<,>)"] >> $gmp_configm4
  1389.   echo ["ifdef(<__CONFIG_M4_INCLUDED__>,,<"] >> $gmp_configm4
  1390.   cat $gmp_tmpconfigm4 >> $gmp_configm4
  1391.   echo [">)"] >> $gmp_configm4
  1392.   echo ["changequote(`,')"] >> $gmp_configm4
  1393.   rm $gmp_tmpconfigm4
  1394. fi
  1395. echo ["ifdef(`__CONFIG_M4_INCLUDED__',,`"] >> $gmp_configm4
  1396. if test -f $gmp_tmpconfigm4i; then
  1397.   cat $gmp_tmpconfigm4i >> $gmp_configm4
  1398.   rm $gmp_tmpconfigm4i
  1399. fi
  1400. if test -f $gmp_tmpconfigm4p; then
  1401.   cat $gmp_tmpconfigm4p >> $gmp_configm4
  1402.   rm $gmp_tmpconfigm4p
  1403. fi
  1404. echo ["')"] >> $gmp_configm4
  1405. echo ["define(`__CONFIG_M4_INCLUDED__')"] >> $gmp_configm4
  1406. ])
  1407. dnl  GMP_INCLUDE_MPN(FILE)
  1408. dnl  ---------------------
  1409. dnl  Add an include_mpn(`FILE') to config.m4.  FILE should be a path
  1410. dnl  relative to the mpn source directory, for example
  1411. dnl
  1412. dnl      GMP_INCLUDE_MPN(`x86/x86-defs.m4')
  1413. dnl
  1414. AC_DEFUN([GMP_INCLUDE_MPN],
  1415. [AC_REQUIRE([GMP_INIT])
  1416. echo ["include_mpn(`$1')"] >> $gmp_tmpconfigm4i
  1417. ])
  1418. dnl  GMP_DEFINE(MACRO, DEFINITION [, LOCATION])
  1419. dnl  ------------------------------------------
  1420. dnl  Define M4 macro MACRO as DEFINITION in temporary file.
  1421. dnl
  1422. dnl  If LOCATION is `POST', the definition will appear after any include()
  1423. dnl  directives inserted by GMP_INCLUDE.  Mind the quoting!  No shell
  1424. dnl  variables will get expanded.  Don't forget to invoke GMP_FINISH to
  1425. dnl  create file config.m4.  config.m4 uses `<' and '>' as quote characters
  1426. dnl  for all defines.
  1427. AC_DEFUN([GMP_DEFINE],
  1428. [AC_REQUIRE([GMP_INIT])
  1429. echo ['define(<$1>, <$2>)'] >>ifelse([$3], [POST],
  1430.                               $gmp_tmpconfigm4p, $gmp_tmpconfigm4)
  1431. ])
  1432. dnl  GMP_DEFINE_RAW(STRING [, LOCATION])
  1433. dnl  ------------------------------------
  1434. dnl  Put STRING into config.m4 file.
  1435. dnl
  1436. dnl  If LOCATION is `POST', the definition will appear after any include()
  1437. dnl  directives inserted by GMP_INCLUDE.  Don't forget to invoke GMP_FINISH
  1438. dnl  to create file config.m4.
  1439. AC_DEFUN([GMP_DEFINE_RAW],
  1440. [AC_REQUIRE([GMP_INIT])
  1441. echo [$1] >> ifelse([$2], [POST], $gmp_tmpconfigm4p, $gmp_tmpconfigm4)
  1442. ])
  1443. dnl  GMP_TRY_ASSEMBLE(asm-code,[action-success][,action-fail])
  1444. dnl  ----------------------------------------------------------
  1445. dnl  Attempt to assemble the given code.
  1446. dnl  Do "action-success" if this succeeds, "action-fail" if not.
  1447. dnl
  1448. dnl  conftest.o and conftest.out are available for inspection in
  1449. dnl  "action-success".  If either action does a "break" out of a loop then
  1450. dnl  an explicit "rm -f conftest*" will be necessary.
  1451. dnl
  1452. dnl  This is not unlike AC_TRY_COMPILE, but there's no default includes or
  1453. dnl  anything in "asm-code", everything wanted must be given explicitly.
  1454. AC_DEFUN([GMP_TRY_ASSEMBLE],
  1455. [cat >conftest.s <<EOF
  1456. [$1]
  1457. EOF
  1458. gmp_assemble="$CCAS $CFLAGS $CPPFLAGS conftest.s >conftest.out 2>&1"
  1459. if AC_TRY_EVAL(gmp_assemble); then
  1460.   cat conftest.out >&AC_FD_CC
  1461.   ifelse([$2],,:,[$2])
  1462. else
  1463.   cat conftest.out >&AC_FD_CC
  1464.   echo "configure: failed program was:" >&AC_FD_CC
  1465.   cat conftest.s >&AC_FD_CC
  1466.   ifelse([$3],,:,[$3])
  1467. fi
  1468. rm -f conftest*
  1469. ])
  1470. dnl Checks whether the stack can be marked nonexecutable by passing an option
  1471. dnl to the C-compiler when acting on .s files. Appends that option to ASFLAGS.
  1472. dnl This macro is adapted from one found in GLIBC-2.3.5.
  1473. AC_DEFUN([CL_AS_NOEXECSTACK],[
  1474. dnl AC_REQUIRE([AC_PROG_CC]) GMP uses something else
  1475. AC_CACHE_CHECK([whether assembler supports --noexecstack option],
  1476. cl_cv_as_noexecstack, [dnl
  1477.   cat > conftest.c <<EOF
  1478. void foo() {}
  1479. EOF
  1480.   if AC_TRY_COMMAND([${CC} $CFLAGS $CPPFLAGS
  1481.                      -S -o conftest.s conftest.c >/dev/null]) 
  1482.      && grep .note.GNU-stack conftest.s >/dev/null 
  1483.      && AC_TRY_COMMAND([${CC} $CFLAGS $CPPFLAGS -Wa,--noexecstack
  1484.                        -c -o conftest.o conftest.s >/dev/null])
  1485.   then
  1486.     cl_cv_as_noexecstack=yes
  1487.   else
  1488.     cl_cv_as_noexecstack=no
  1489.   fi
  1490.   rm -f conftest*])
  1491.   if test "$cl_cv_as_noexecstack" = yes; then
  1492.     ASMFLAGS="$ASMFLAGS -Wa,--noexecstack"
  1493.   fi
  1494.   AC_SUBST(ASMFLAGS)
  1495. ])
  1496. dnl  GMP_ASM_LABEL_SUFFIX
  1497. dnl  --------------------
  1498. dnl  : - is usual.
  1499. dnl  empty - hppa on HP-UX doesn't use a :, just the label name
  1500. dnl
  1501. dnl  Note that it's necessary to test the empty case first, since HP "as"
  1502. dnl  will accept "somelabel:", and take it to mean a label with a name that
  1503. dnl  happens to end in a colon.
  1504. AC_DEFUN([GMP_ASM_LABEL_SUFFIX],
  1505. [AC_REQUIRE([GMP_ASM_TEXT])
  1506. AC_CACHE_CHECK([for assembler label suffix],
  1507.                 gmp_cv_asm_label_suffix,
  1508. [gmp_cv_asm_label_suffix=unknown
  1509. for i in "" ":"; do
  1510.   echo "trying $i" >&AC_FD_CC
  1511.   GMP_TRY_ASSEMBLE(
  1512. [ $gmp_cv_asm_text
  1513. somelabel$i],
  1514.     [gmp_cv_asm_label_suffix=$i
  1515.      rm -f conftest*
  1516.      break],
  1517.     [cat conftest.out >&AC_FD_CC])
  1518. done
  1519. if test "$gmp_cv_asm_label_suffix" = "unknown"; then
  1520.   AC_MSG_ERROR([Cannot determine label suffix])
  1521. fi
  1522. ])
  1523. echo ["define(<LABEL_SUFFIX>, <$gmp_cv_asm_label_suffix>)"] >> $gmp_tmpconfigm4
  1524. ])
  1525. dnl  GMP_ASM_UNDERSCORE
  1526. dnl  ------------------
  1527. dnl  Determine whether global symbols need to be prefixed with an underscore.
  1528. dnl  The output from "nm" is grepped to see what a typical symbol looks like.
  1529. dnl
  1530. dnl  This test used to grep the .o file directly, but that failed with greps
  1531. dnl  that don't like binary files (eg. SunOS 4).
  1532. dnl
  1533. dnl  This test also used to construct an assembler file with and without an
  1534. dnl  underscore and try to link that to a C file, to see which worked.
  1535. dnl  Although that's what will happen in the real build we don't really want
  1536. dnl  to depend on creating asm files within configure for every possible CPU
  1537. dnl  (or at least we don't want to do that more than we have to).
  1538. dnl
  1539. dnl  The fallback on no underscore is based on the assumption that the world
  1540. dnl  is moving towards non-underscore systems.  There should actually be no
  1541. dnl  good reason for nm to fail though.
  1542. AC_DEFUN([GMP_ASM_UNDERSCORE],
  1543. [AC_REQUIRE([GMP_PROG_NM])
  1544. AC_CACHE_CHECK([if globals are prefixed by underscore],
  1545.                gmp_cv_asm_underscore,
  1546. [gmp_cv_asm_underscore="unknown"
  1547. cat >conftest.c <<EOF
  1548. int gurkmacka;
  1549. EOF
  1550. gmp_compile="$CC $CFLAGS $CPPFLAGS -c conftest.c >&AC_FD_CC"
  1551. if AC_TRY_EVAL(gmp_compile); then
  1552.   $NM conftest.$OBJEXT >conftest.out
  1553.   if grep _gurkmacka conftest.out >/dev/null; then
  1554.     gmp_cv_asm_underscore=yes
  1555.   elif grep gurkmacka conftest.out >/dev/null; then
  1556.     gmp_cv_asm_underscore=no
  1557.   else
  1558.     echo "configure: $NM doesn't have gurkmacka:" >&AC_FD_CC
  1559.     cat conftest.out >&AC_FD_CC
  1560.   fi
  1561. else
  1562.   echo "configure: failed program was:" >&AC_FD_CC
  1563.   cat conftest.c >&AC_FD_CC
  1564. fi
  1565. rm -f conftest*
  1566. ])
  1567. case $gmp_cv_asm_underscore in
  1568.   yes)
  1569.     GMP_DEFINE(GSYM_PREFIX, [_]) ;;
  1570.   no)
  1571.     GMP_DEFINE(GSYM_PREFIX, []) ;;
  1572.   *)
  1573.     AC_MSG_WARN([+----------------------------------------------------------])
  1574.     AC_MSG_WARN([| Cannot determine global symbol prefix.])
  1575.     AC_MSG_WARN([| $NM output doesn't contain a global data symbol.])
  1576.     AC_MSG_WARN([| Will proceed with no underscore.])
  1577.     AC_MSG_WARN([| If this is wrong then you'll get link errors referring])
  1578.     AC_MSG_WARN([| to ___gmpn_add_n (note three underscores).])
  1579.     AC_MSG_WARN([| In this case do a fresh build with an override,])
  1580.     AC_MSG_WARN([|     ./configure gmp_cv_asm_underscore=yes])
  1581.     AC_MSG_WARN([+----------------------------------------------------------])
  1582.     GMP_DEFINE(GSYM_PREFIX, [])
  1583.     ;;
  1584. esac
  1585. ])
  1586. dnl  GMP_ASM_ALIGN_LOG
  1587. dnl  -----------------
  1588. dnl  Is parameter to `.align' logarithmic?
  1589. AC_DEFUN([GMP_ASM_ALIGN_LOG],
  1590. [AC_REQUIRE([GMP_ASM_GLOBL])
  1591. AC_REQUIRE([GMP_ASM_BYTE])
  1592. AC_REQUIRE([GMP_ASM_DATA])
  1593. AC_REQUIRE([GMP_ASM_LABEL_SUFFIX])
  1594. AC_REQUIRE([GMP_PROG_NM])
  1595. AC_CACHE_CHECK([if .align assembly directive is logarithmic],
  1596.                gmp_cv_asm_align_log,
  1597. [GMP_TRY_ASSEMBLE(
  1598. [       $gmp_cv_asm_data
  1599.        .align  4
  1600. $gmp_cv_asm_globl foo
  1601. $gmp_cv_asm_byte 1
  1602. .align 4
  1603. foo$gmp_cv_asm_label_suffix
  1604. $gmp_cv_asm_byte 2],
  1605.   [gmp_tmp_val=[`$NM conftest.$OBJEXT | grep foo | 
  1606.      sed -e 's;[[][0-9][]](.*);1;' -e 's;[^1-9]*([0-9]*).*;1;'`]
  1607.   if test "$gmp_tmp_val" = "10" || test "$gmp_tmp_val" = "16"; then
  1608.     gmp_cv_asm_align_log=yes
  1609.   else
  1610.     gmp_cv_asm_align_log=no
  1611.   fi],
  1612.   [AC_MSG_ERROR([cannot assemble alignment test])])])
  1613. GMP_DEFINE_RAW(["define(<ALIGN_LOGARITHMIC>,<$gmp_cv_asm_align_log>)"])
  1614. ])
  1615. dnl  GMP_ASM_ALIGN_FILL_0x90
  1616. dnl  -----------------------
  1617. dnl  Determine whether a ",0x90" suffix works on a .align directive.
  1618. dnl  This is only meant for use on x86, 0x90 being a "nop".
  1619. dnl
  1620. dnl  Old gas, eg. 1.92.3
  1621. dnl       Needs ",0x90" or else the fill is 0x00, which can't be executed
  1622. dnl       across.
  1623. dnl
  1624. dnl  New gas, eg. 2.91
  1625. dnl       Generates multi-byte nop fills even when ",0x90" is given.
  1626. dnl
  1627. dnl  Solaris 2.6 as
  1628. dnl       ",0x90" is not allowed, causes a fatal error.
  1629. dnl
  1630. dnl  Solaris 2.8 as
  1631. dnl       ",0x90" does nothing, generates a warning that it's being ignored.
  1632. dnl
  1633. dnl  SCO OpenServer 5 as
  1634. dnl       Second parameter is max bytes to fill, not a fill pattern.
  1635. dnl       ",0x90" is an error due to being bigger than the first parameter.
  1636. dnl       Multi-byte nop fills are generated in text segments.
  1637. dnl
  1638. dnl  Note that both solaris "as"s only care about ",0x90" if they actually
  1639. dnl  have to use it to fill something, hence the .byte in the test.  It's
  1640. dnl  the second .align which provokes the error or warning.
  1641. dnl
  1642. dnl  The warning from solaris 2.8 is suppressed to stop anyone worrying that
  1643. dnl  something might be wrong.
  1644. AC_DEFUN([GMP_ASM_ALIGN_FILL_0x90],
  1645. [AC_REQUIRE([GMP_ASM_TEXT])
  1646. AC_CACHE_CHECK([if the .align directive accepts an 0x90 fill in .text],
  1647.                gmp_cv_asm_align_fill_0x90,
  1648. [GMP_TRY_ASSEMBLE(
  1649. [       $gmp_cv_asm_text
  1650.        .align  4, 0x90
  1651. .byte   0
  1652.        .align  4, 0x90],
  1653. [if grep "Warning: Fill parameter ignored for executable section" conftest.out >/dev/null; then
  1654.   echo "Supressing this warning by omitting 0x90" 1>&AC_FD_CC
  1655.   gmp_cv_asm_align_fill_0x90=no
  1656. else
  1657.   gmp_cv_asm_align_fill_0x90=yes
  1658. fi],
  1659. [gmp_cv_asm_align_fill_0x90=no])])
  1660. GMP_DEFINE_RAW(["define(<ALIGN_FILL_0x90>,<$gmp_cv_asm_align_fill_0x90>)"])
  1661. ])
  1662. dnl  GMP_ASM_BYTE
  1663. dnl  ------------
  1664. dnl  .byte - is usual.
  1665. dnl  data1 - required by ia64 (on hpux at least).
  1666. dnl
  1667. dnl  This macro is just to support other configure tests, not any actual asm
  1668. dnl  code.
  1669. AC_DEFUN([GMP_ASM_BYTE],
  1670. [AC_REQUIRE([GMP_ASM_TEXT])
  1671. AC_REQUIRE([GMP_ASM_LABEL_SUFFIX])
  1672. AC_CACHE_CHECK([for assembler byte directive],
  1673.                 gmp_cv_asm_byte,
  1674. [for i in .byte data1; do
  1675.   echo "trying $i" >&AC_FD_CC
  1676.   GMP_TRY_ASSEMBLE(
  1677. [ $gmp_cv_asm_data
  1678. $i 0
  1679. ],
  1680.     [gmp_cv_asm_byte=$i
  1681.      rm -f conftest*
  1682.      break],
  1683.     [cat conftest.out >&AC_FD_CC])
  1684. done
  1685. if test -z "$gmp_cv_asm_byte"; then
  1686.   AC_MSG_ERROR([Cannot determine how to emit a data byte])
  1687. fi
  1688. ])
  1689. ])
  1690. dnl  GMP_ASM_TEXT
  1691. dnl  ------------
  1692. dnl  .text - is usual.
  1693. dnl  .code - is needed by the hppa on HP-UX (but ia64 HP-UX uses .text)
  1694. dnl  .csect .text[PR] - is for AIX.
  1695. AC_DEFUN([GMP_ASM_TEXT],
  1696. [AC_CACHE_CHECK([how to switch to text section],
  1697.                 gmp_cv_asm_text,
  1698. [for i in ".text" ".code" [".csect .text[PR]"]; do
  1699.   echo "trying $i" >&AC_FD_CC
  1700.   GMP_TRY_ASSEMBLE([ $i],
  1701.     [gmp_cv_asm_text=$i
  1702.      rm -f conftest*
  1703.      break])
  1704. done
  1705. if test -z "$gmp_cv_asm_text"; then
  1706.   AC_MSG_ERROR([Cannot determine text section directive])
  1707. fi
  1708. ])
  1709. echo ["define(<TEXT>, <$gmp_cv_asm_text>)"] >> $gmp_tmpconfigm4
  1710. ])
  1711. dnl  GMP_ASM_DATA
  1712. dnl  ------------
  1713. dnl  Can we say `.data'?
  1714. AC_DEFUN([GMP_ASM_DATA],
  1715. [AC_CACHE_CHECK([how to switch to data section],
  1716.                 gmp_cv_asm_data,
  1717. [case $host in
  1718.   *-*-aix*) gmp_cv_asm_data=[".csect .data[RW]"] ;;
  1719.   *)        gmp_cv_asm_data=".data" ;;
  1720. esac
  1721. ])
  1722. echo ["define(<DATA>, <$gmp_cv_asm_data>)"] >> $gmp_tmpconfigm4
  1723. ])
  1724. dnl  GMP_ASM_RODATA
  1725. dnl  --------------
  1726. dnl  Find out how to switch to the read-only data section.
  1727. dnl
  1728. dnl  The compiler output is grepped for the right directive.  It's not
  1729. dnl  considered wise to just probe for ".section .rodata" or whatever works,
  1730. dnl  since arbitrary section names might be accepted, but not necessarily do
  1731. dnl  the right thing when they get to the linker.
  1732. dnl
  1733. dnl  Only a few asm files use RODATA, so this code is perhaps a bit
  1734. dnl  excessive right now, but should find more uses in the future.
  1735. dnl
  1736. dnl  FIXME: gcc on aix generates something like ".csect _foo.ro_c[RO],3"
  1737. dnl  where foo is the object file.  Might need to check for that if we use
  1738. dnl  RODATA there.
  1739. AC_DEFUN([GMP_ASM_RODATA],
  1740. [AC_REQUIRE([GMP_ASM_TEXT])
  1741. AC_REQUIRE([GMP_ASM_DATA])
  1742. AC_REQUIRE([GMP_ASM_LABEL_SUFFIX])
  1743. AC_REQUIRE([GMP_ASM_UNDERSCORE])
  1744. AC_CACHE_CHECK([how to switch to read-only data section],
  1745.                gmp_cv_asm_rodata,
  1746. [
  1747. dnl Default to DATA on CPUs with split code/data caching, and TEXT
  1748. dnl elsewhere.  i386 means generic x86, so use DATA on it.
  1749. case $host in
  1750. X86_PATTERN | x86_64-*-*)
  1751.   gmp_cv_asm_rodata="$gmp_cv_asm_data" ;;
  1752. *)
  1753.   gmp_cv_asm_rodata="$gmp_cv_asm_text" ;;
  1754. esac
  1755. cat >conftest.c <<EOF
  1756. const int foo = 123;
  1757. EOF
  1758. echo "Test program:" >&AC_FD_CC
  1759. cat conftest.c >&AC_FD_CC
  1760. gmp_compile="$CC $CFLAGS $CPPFLAGS -S conftest.c >&AC_FD_CC"
  1761. if AC_TRY_EVAL(gmp_compile); then
  1762.   echo "Compiler output:" >&AC_FD_CC
  1763.   cat conftest.s >&AC_FD_CC
  1764.   if test $gmp_cv_asm_underscore = yes; then
  1765.     tmp_gsym_prefix=_
  1766.   else
  1767.     tmp_gsym_prefix=
  1768.   fi
  1769.   # must see our label
  1770.   if grep "^${tmp_gsym_prefix}foo$gmp_cv_asm_label_suffix" conftest.s >/dev/null 2>&AC_FD_CC; then
  1771.     # take the last directive before our label (hence skipping segments
  1772.     # getting debugging info etc)
  1773.     tmp_match=`sed -n ["/^${tmp_gsym_prefix}foo$gmp_cv_asm_label_suffix/q
  1774.                         /^[.  ]*data/p
  1775.                         /^[.  ]*rdata/p
  1776.                         /^[.  ]*text/p
  1777.                         /^[.  ]*section/p
  1778.                         /^[.  ]*csect/p
  1779.                         /^[.  ]*CSECT/p"] conftest.s | sed -n '$p'`
  1780.     echo "Match: $tmp_match" >&AC_FD_CC
  1781.     if test -n "$tmp_match"; then
  1782.       gmp_cv_asm_rodata=$tmp_match
  1783.     fi
  1784.   else
  1785.     echo "Couldn't find label: ^${tmp_gsym_prefix}foo$gmp_cv_asm_label_suffix" >&AC_FD_CC
  1786.   fi
  1787. fi
  1788. rm -f conftest*
  1789. ])
  1790. echo ["define(<RODATA>, <$gmp_cv_asm_rodata>)"] >> $gmp_tmpconfigm4
  1791. ])
  1792. dnl  GMP_ASM_GLOBL
  1793. dnl  -------------
  1794. dnl  The assembler directive to mark a label as a global symbol.
  1795. dnl
  1796. dnl  ia64 - .global is standard, according to the Intel documentation.
  1797. dnl
  1798. dnl  hppa - ".export foo,entry" is demanded by HP hppa "as".  ".global" is a
  1799. dnl      kind of import.
  1800. dnl
  1801. dnl  other - .globl is usual.
  1802. dnl
  1803. dnl  "gas" tends to accept .globl everywhere, in addition to .export or
  1804. dnl  .global or whatever the system assembler demands.
  1805. AC_DEFUN([GMP_ASM_GLOBL],
  1806. [AC_REQUIRE([GMP_ASM_TEXT])
  1807. AC_CACHE_CHECK([for assembler global directive],
  1808.                 gmp_cv_asm_globl,
  1809. [case $host in
  1810.   hppa*-*-*)     gmp_cv_asm_globl=.export ;;
  1811.   IA64_PATTERN)  gmp_cv_asm_globl=.global ;;
  1812.   *)             gmp_cv_asm_globl=.globl  ;;
  1813. esac
  1814. ])
  1815. echo ["define(<GLOBL>, <$gmp_cv_asm_globl>)"] >> $gmp_tmpconfigm4
  1816. ])
  1817. dnl  GMP_ASM_GLOBL_ATTR
  1818. dnl  ------------------
  1819. dnl  Do we need something after `GLOBL symbol'?
  1820. AC_DEFUN([GMP_ASM_GLOBL_ATTR],
  1821. [AC_REQUIRE([GMP_ASM_GLOBL])
  1822. AC_CACHE_CHECK([for assembler global directive attribute],
  1823.                 gmp_cv_asm_globl_attr,
  1824. [case $gmp_cv_asm_globl in
  1825.   .export) gmp_cv_asm_globl_attr=",entry" ;;
  1826.   *)       gmp_cv_asm_globl_attr="" ;;
  1827. esac
  1828. ])
  1829. echo ["define(<GLOBL_ATTR>, <$gmp_cv_asm_globl_attr>)"] >> $gmp_tmpconfigm4
  1830. ])
  1831. dnl  GMP_ASM_TYPE
  1832. dnl  ------------
  1833. dnl  Can we say ".type", and how?
  1834. dnl
  1835. dnl  For i386 GNU/Linux ELF systems, and very likely other ELF systems,
  1836. dnl  .type and .size are important on functions in shared libraries.  If
  1837. dnl  .type is omitted and the mainline program references that function then
  1838. dnl  the code will be copied down to the mainline at load time like a piece
  1839. dnl  of data.  If .size is wrong or missing (it defaults to 4 bytes or some
  1840. dnl  such) then incorrect bytes will be copied and a segv is the most likely
  1841. dnl  result.  In any case such copying is not what's wanted, a .type
  1842. dnl  directive will ensure a PLT entry is used.
  1843. dnl
  1844. dnl  In GMP the assembler functions are normally only used from within the
  1845. dnl  library (since most programs are not interested in the low level
  1846. dnl  routines), and in those circumstances a missing .type isn't fatal,
  1847. dnl  letting the problem go unnoticed.  tests/mpn/t-asmtype.c aims to check
  1848. dnl  for it.
  1849. AC_DEFUN([GMP_ASM_TYPE],
  1850. [AC_CACHE_CHECK([for assembler .type directive],
  1851.                 gmp_cv_asm_type,
  1852. [gmp_cv_asm_type=
  1853. for gmp_tmp_prefix in @ # %; do
  1854.   GMP_TRY_ASSEMBLE([ .type sym,${gmp_tmp_prefix}function],
  1855.     [if grep ".type pseudo-op used outside of .def/.endef ignored" conftest.out >/dev/null; then : ;
  1856.     else
  1857.       gmp_cv_asm_type=".type $][1,${gmp_tmp_prefix}$][2"
  1858.       break
  1859.     fi])
  1860. done
  1861. rm -f conftest*
  1862. ])
  1863. echo ["define(<TYPE>, <$gmp_cv_asm_type>)"] >> $gmp_tmpconfigm4
  1864. ])
  1865. dnl  GMP_ASM_SIZE
  1866. dnl  ------------
  1867. dnl  Can we say `.size'?
  1868. AC_DEFUN([GMP_ASM_SIZE],
  1869. [AC_CACHE_CHECK([for assembler .size directive],
  1870.                 gmp_cv_asm_size,
  1871. [gmp_cv_asm_size=
  1872. GMP_TRY_ASSEMBLE([ .size sym,1],
  1873.   [if grep ".size pseudo-op used outside of .def/.endef ignored" conftest.out >/dev/null; then : ;
  1874.   else
  1875.     gmp_cv_asm_size=".size $][1,$][2"
  1876.   fi])
  1877. ])
  1878. echo ["define(<SIZE>, <$gmp_cv_asm_size>)"] >> $gmp_tmpconfigm4
  1879. ])
  1880. dnl  GMP_ASM_COFF_TYPE
  1881. dnl  -----------------
  1882. dnl  Determine whether the assembler supports COFF type information.
  1883. dnl
  1884. dnl  Currently this is only needed for mingw (and cygwin perhaps) and so is
  1885. dnl  run only on the x86s, but it ought to work anywhere.
  1886. dnl
  1887. dnl  On MINGW, recent versions of the linker have an automatic import scheme
  1888. dnl  for data in a DLL which is referenced by a mainline but without
  1889. dnl  __declspec (__dllimport__) on the prototype.  It seems functions
  1890. dnl  without type information are treated as data, or something, and calls
  1891. dnl  to them from the mainline will crash.  gcc puts type information on the
  1892. dnl  C functions it generates, we need to do the same for assembler
  1893. dnl  functions.
  1894. dnl
  1895. dnl  This applies only to functions without __declspec(__dllimport__),
  1896. dnl  ie. without __GMP_DECLSPEC in the case of libgmp, so it also works just
  1897. dnl  to ensure all assembler functions used from outside libgmp have
  1898. dnl  __GMP_DECLSPEC on their prototypes.  But this isn't an ideal situation,
  1899. dnl  since we don't want perfectly valid calls going wrong just because
  1900. dnl  there wasn't a prototype in scope.
  1901. dnl
  1902. dnl  When an auto-import takes place, the following warning is given by the
  1903. dnl  linker.  This shouldn't be seen for any functions.
  1904. dnl
  1905. dnl      Info: resolving _foo by linking to __imp__foo (auto-import)
  1906. dnl
  1907. dnl
  1908. dnl  COFF type directives look like the following
  1909. dnl
  1910. dnl      .def    _foo
  1911. dnl      .scl    2
  1912. dnl      .type   32
  1913. dnl      .endef
  1914. dnl
  1915. dnl  _foo is the symbol with GSYM_PREFIX (_).  .scl is the storage class, 2
  1916. dnl  for external, 3 for static.  .type is the object type, 32 for a
  1917. dnl  function.
  1918. dnl
  1919. dnl  On an ELF system, this is (correctly) rejected due to .def, .endef and
  1920. dnl  .scl being invalid, and .type not having enough arguments.
  1921. AC_DEFUN([GMP_ASM_COFF_TYPE],
  1922. [AC_REQUIRE([GMP_ASM_TEXT])
  1923. AC_REQUIRE([GMP_ASM_GLOBL])
  1924. AC_REQUIRE([GMP_ASM_GLOBL_ATTR])
  1925. AC_REQUIRE([GMP_ASM_LABEL_SUFFIX])
  1926. AC_REQUIRE([GMP_ASM_UNDERSCORE])
  1927. AC_CACHE_CHECK([for assembler COFF type directives],
  1928. gmp_cv_asm_x86_coff_type,
  1929. [GMP_TRY_ASSEMBLE(
  1930. [ $gmp_cv_asm_text
  1931. $gmp_cv_asm_globl ${tmp_gsym_prefix}foo$gmp_cv_asm_globl_attr
  1932. .def ${tmp_gsym_prefix}foo
  1933. .scl 2
  1934. .type 32
  1935. .endef
  1936. ${tmp_gsym_prefix}foo$gmp_cv_asm_label_suffix
  1937. ],
  1938.   [gmp_cv_asm_x86_coff_type=yes],
  1939.   [gmp_cv_asm_x86_coff_type=no])
  1940. ])
  1941. echo ["define(<HAVE_COFF_TYPE>, <$gmp_cv_asm_x86_coff_type>)"] >> $gmp_tmpconfigm4
  1942. ])
  1943. dnl  GMP_ASM_LSYM_PREFIX
  1944. dnl  -------------------
  1945. dnl  What is the prefix for a local label?
  1946. dnl
  1947. dnl  The prefixes tested are,
  1948. dnl
  1949. dnl      L  - usual for underscore systems
  1950. dnl      .L - usual for non-underscore systems
  1951. dnl      $  - alpha (gas and OSF system assembler)
  1952. dnl      L$ - hppa (gas and HP-UX system assembler)
  1953. dnl
  1954. dnl  The default is "L" if the tests fail for any reason.  There's a good
  1955. dnl  chance this will be adequate, since on most systems labels are local
  1956. dnl  anyway unless given a ".globl", and an "L" will avoid clashes with
  1957. dnl  other identifers.
  1958. dnl
  1959. dnl  For gas, ".L" is normally purely local to the assembler, it doesn't get
  1960. dnl  put into the object file at all.  This style is preferred, to keep the
  1961. dnl  object files nice and clean.
  1962. dnl
  1963. dnl  BSD format nm produces a line like
  1964. dnl
  1965. dnl      00000000 t Lgurkmacka
  1966. dnl
  1967. dnl  The symbol code is normally "t" for text, but any lower case letter
  1968. dnl  indicates a local definition.
  1969. dnl
  1970. dnl  Code "n" is for a debugging symbol, OSF "nm -B" gives that as an upper
  1971. dnl  case "N" for a local.
  1972. dnl
  1973. dnl  HP-UX nm prints an error message (though seems to give a 0 exit) if
  1974. dnl  there's no symbols at all in an object file, hence the use of "dummy".
  1975. AC_DEFUN([GMP_ASM_LSYM_PREFIX],
  1976. [AC_REQUIRE([GMP_ASM_LABEL_SUFFIX])
  1977. AC_REQUIRE([GMP_ASM_TEXT])
  1978. AC_REQUIRE([GMP_PROG_NM])
  1979. AC_CACHE_CHECK([for assembler local label prefix],
  1980.                gmp_cv_asm_lsym_prefix,
  1981. [gmp_tmp_pre_appears=yes
  1982. for gmp_tmp_pre in L .L $L $ L$; do
  1983.   echo "Trying $gmp_tmp_pre" >&AC_FD_CC
  1984.   GMP_TRY_ASSEMBLE(
  1985. [ $gmp_cv_asm_text
  1986. dummy${gmp_cv_asm_label_suffix}
  1987. ${gmp_tmp_pre}gurkmacka${gmp_cv_asm_label_suffix}],
  1988.   [if $NM conftest.$OBJEXT >conftest.nm 2>&AC_FD_CC; then : ; else
  1989.     cat conftest.nm >&AC_FD_CC
  1990.     AC_MSG_WARN(["$NM" failure])
  1991.     break
  1992.   fi
  1993.   cat conftest.nm >&AC_FD_CC
  1994.   if grep gurkmacka conftest.nm >/dev/null; then : ; else
  1995.     # no mention of the symbol, this is good
  1996.     echo "$gmp_tmp_pre label doesn't appear in object file at all (good)" >&AC_FD_CC
  1997.     gmp_cv_asm_lsym_prefix="$gmp_tmp_pre"
  1998.     gmp_tmp_pre_appears=no
  1999.     break
  2000.   fi
  2001.   if grep [' [a-zN] .*gurkmacka'] conftest.nm >/dev/null; then
  2002.     # symbol mentioned as a local, use this if nothing better
  2003.     echo "$gmp_tmp_pre label is local but still in object file" >&AC_FD_CC
  2004.     if test -z "$gmp_cv_asm_lsym_prefix"; then
  2005.       gmp_cv_asm_lsym_prefix="$gmp_tmp_pre"
  2006.     fi
  2007.   else
  2008.     echo "$gmp_tmp_pre label is something unknown" >&AC_FD_CC
  2009.   fi
  2010.   ])
  2011. done
  2012. rm -f conftest*
  2013. if test -z "$gmp_cv_asm_lsym_prefix"; then
  2014.   gmp_cv_asm_lsym_prefix=L
  2015.   AC_MSG_WARN([cannot determine local label, using default $gmp_cv_asm_lsym_prefix])
  2016. fi
  2017. # for development purposes, note whether we got a purely temporary local label
  2018. echo "Local label appears in object files: $gmp_tmp_pre_appears" >&AC_FD_CC
  2019. ])
  2020. echo ["define(<LSYM_PREFIX>, <${gmp_cv_asm_lsym_prefix}>)"] >> $gmp_tmpconfigm4
  2021. AC_DEFINE_UNQUOTED(LSYM_PREFIX, "$gmp_cv_asm_lsym_prefix",
  2022.                    [Assembler local label prefix])
  2023. ])
  2024. dnl  GMP_ASM_W32
  2025. dnl  -----------
  2026. dnl  How to define a 32-bit word.
  2027. dnl
  2028. dnl  FIXME: This test is not right for ia64-*-hpux*.  The directive should
  2029. dnl  be "data4", but the W32 macro is not currently used by the mpn/ia64 asm
  2030. dnl  files.
  2031. AC_DEFUN([GMP_ASM_W32],
  2032. [AC_REQUIRE([GMP_ASM_DATA])
  2033. AC_REQUIRE([GMP_ASM_BYTE])
  2034. AC_REQUIRE([GMP_ASM_GLOBL])
  2035. AC_REQUIRE([GMP_ASM_LABEL_SUFFIX])
  2036. AC_REQUIRE([GMP_PROG_NM])
  2037. AC_CACHE_CHECK([how to define a 32-bit word],
  2038.        gmp_cv_asm_w32,
  2039. [case $host in
  2040.   *-*-hpux*)
  2041.     # FIXME: HPUX puts first symbol at 0x40000000, breaking our assumption
  2042.     # that it's at 0x0.  We'll have to declare another symbol before the
  2043.     # .long/.word and look at the distance between the two symbols.  The
  2044.     # only problem is that the sed expression(s) barfs (on Solaris, for
  2045.     # example) for the symbol with value 0.  For now, HPUX uses .word.
  2046.     gmp_cv_asm_w32=".word"
  2047.     ;;
  2048.   *-*-*)
  2049.     gmp_tmp_val=
  2050.     for gmp_tmp_op in .long .word data4; do
  2051.       GMP_TRY_ASSEMBLE(
  2052. [ $gmp_cv_asm_data
  2053. $gmp_cv_asm_globl foo
  2054. $gmp_tmp_op 0
  2055. foo$gmp_cv_asm_label_suffix
  2056. $gmp_cv_asm_byte 0],
  2057.         [gmp_tmp_val=[`$NM conftest.$OBJEXT | grep foo | 
  2058.           sed -e 's;[[][0-9][]](.*);1;' -e 's;[^1-9]*([0-9]*).*;1;'`]
  2059.         if test "$gmp_tmp_val" = 4; then
  2060.           gmp_cv_asm_w32="$gmp_tmp_op"
  2061.           break
  2062.         fi])
  2063.     done
  2064.     rm -f conftest*
  2065.     ;;
  2066. esac
  2067. if test -z "$gmp_cv_asm_w32"; then
  2068.   AC_MSG_ERROR([cannot determine how to define a 32-bit word])
  2069. fi
  2070. ])
  2071. echo ["define(<W32>, <$gmp_cv_asm_w32>)"] >> $gmp_tmpconfigm4
  2072. ])
  2073. dnl  GMP_X86_ASM_GOT_UNDERSCORE
  2074. dnl  --------------------------
  2075. dnl  Determine whether i386 _GLOBAL_OFFSET_TABLE_ needs an additional
  2076. dnl  underscore prefix.
  2077. dnl
  2078. dnl    SVR4      - the standard is _GLOBAL_OFFSET_TABLE_
  2079. dnl    GNU/Linux - follows SVR4
  2080. dnl    OpenBSD   - an a.out underscore system, uses __GLOBAL_OFFSET_TABLE_
  2081. dnl    NetBSD    - also an a.out underscore system, but _GLOBAL_OFFSET_TABLE_
  2082. dnl
  2083. dnl  The test attempts to link a program using _GLOBAL_OFFSET_TABLE_ or
  2084. dnl  __GLOBAL_OFFSET_TABLE_ to see which works.
  2085. dnl
  2086. dnl  $lt_prog_compiler_pic is included in the compile because old versions
  2087. dnl  of gas wouldn't accept PIC idioms without the right option (-K).  This
  2088. dnl  is the same as what libtool and mpn/Makeasm.am will do.
  2089. dnl
  2090. dnl  $lt_prog_compiler_pic is also included in the link because OpenBSD ld
  2091. dnl  won't accept an R_386_GOTPC relocation without the right options.  This
  2092. dnl  is not what's done by the Makefiles when building executables, but
  2093. dnl  let's hope it's ok (it works fine with gcc).
  2094. dnl
  2095. dnl  The fallback is no additional underscore, on the basis that this will
  2096. dnl  suit SVR4/ELF style systems, which should be much more common than
  2097. dnl  a.out systems with shared libraries.
  2098. dnl
  2099. dnl  Note that it's not an error for the tests to fail, since for instance
  2100. dnl  cygwin, mingw and djgpp don't have a _GLOBAL_OFFSET_TABLE_ scheme at
  2101. dnl  all.
  2102. dnl
  2103. dnl  Perhaps $CCAS could be asked to do the linking as well as the
  2104. dnl  assembling, but in the Makefiles it's only used for assembling, so lets
  2105. dnl  keep it that way.
  2106. dnl
  2107. dnl  The test here is run even under --disable-shared, so that PIC objects
  2108. dnl  can be built and tested by the tune/many.pl development scheme.  The
  2109. dnl  tests will be reasonably quick and won't give a fatal error, so this
  2110. dnl  arrangement is ok.  AC_LIBTOOL_PROG_COMPILER_PIC does its
  2111. dnl  $lt_prog_compiler_pic setups even for --disable-shared too.
  2112. AC_DEFUN([GMP_ASM_X86_GOT_UNDERSCORE],
  2113. [AC_REQUIRE([GMP_ASM_TEXT])
  2114. AC_REQUIRE([GMP_ASM_GLOBL])
  2115. AC_REQUIRE([GMP_ASM_GLOBL_ATTR])
  2116. AC_REQUIRE([GMP_ASM_LABEL_SUFFIX])
  2117. AC_REQUIRE([GMP_ASM_UNDERSCORE])
  2118. AC_REQUIRE([AC_LIBTOOL_PROG_COMPILER_PIC])
  2119. AC_CACHE_CHECK([if _GLOBAL_OFFSET_TABLE_ is prefixed by underscore],
  2120.                gmp_cv_asm_x86_got_underscore,
  2121. [gmp_cv_asm_x86_got_underscore="not applicable"
  2122. if test $gmp_cv_asm_underscore = yes; then
  2123.   tmp_gsym_prefix=_
  2124. else
  2125.   tmp_gsym_prefix=
  2126. fi
  2127. for tmp_underscore in "" "_"; do
  2128.   cat >conftest.s <<EOF
  2129. $gmp_cv_asm_text
  2130. $gmp_cv_asm_globl ${tmp_gsym_prefix}main$gmp_cv_asm_globl_attr
  2131. ${tmp_gsym_prefix}main$gmp_cv_asm_label_suffix
  2132. addl $ ${tmp_underscore}_GLOBAL_OFFSET_TABLE_, %ebx
  2133. EOF
  2134.   gmp_compile="$CCAS $CFLAGS $CPPFLAGS $lt_prog_compiler_pic conftest.s >&AC_FD_CC && $CC $CFLAGS $CPPFLAGS $lt_prog_compiler_pic conftest.$OBJEXT >&AC_FD_CC"
  2135.   if AC_TRY_EVAL(gmp_compile); then
  2136.     if test "$tmp_underscore" = "_"; then
  2137.       gmp_cv_asm_x86_got_underscore=yes
  2138.     else
  2139.       gmp_cv_asm_x86_got_underscore=no
  2140.     fi
  2141.     break
  2142.   fi
  2143. done
  2144. rm -f conftest* a.out b.out a.exe a_out.exe
  2145. ])
  2146. if test "$gmp_cv_asm_x86_got_underscore" = "yes"; then
  2147.   GMP_DEFINE(GOT_GSYM_PREFIX, [_])
  2148. else
  2149.   GMP_DEFINE(GOT_GSYM_PREFIX, [])
  2150. fi
  2151. ])
  2152. dnl  GMP_ASM_X86_GOT_EAX_OK(CC+CFLAGS, [ACTION-YES] [, ACTION-NO])
  2153. dnl  -------------------------------------------------------------
  2154. dnl  Determine whether _GLOBAL_OFFSET_TABLE_ used with %eax is ok.
  2155. dnl
  2156. dnl  An instruction
  2157. dnl
  2158. dnl          addl  $_GLOBAL_OFFSET_TABLE_, %eax
  2159. dnl
  2160. dnl  is incorrectly assembled by gas 2.12 (or thereabouts) and earlier.  It
  2161. dnl  puts an addend 2 into the R_386_GOTPC relocation, but it should be 1
  2162. dnl  for this %eax form being a 1 byte opcode (with other registers it's 2
  2163. dnl  opcode bytes).  See note about this in mpn/x86/README too.
  2164. dnl
  2165. dnl  We assemble this, surrounded by some unlikely byte sequences as
  2166. dnl  delimiters, and check for the bad output.
  2167. dnl
  2168. dnl  This is for use by compiler probing in GMP_PROG_CC_WORKS, so the result
  2169. dnl  is not cached.
  2170. dnl
  2171. dnl  This test is not specific to gas, but old gas is the only assembler we
  2172. dnl  know of with this problem.  The Solaris has been seen coming out ok.
  2173. dnl
  2174. dnl  ".text" is hard coded because this macro is wanted before GMP_ASM_TEXT.
  2175. dnl  This should be fine, ".text" is normal on x86 systems, and certainly
  2176. dnl  will be fine with the offending gas.
  2177. dnl
  2178. dnl  If an error occurs when assembling, we consider the assembler ok, since
  2179. dnl  the bad output does not occur.  This happens for instance on mingw,
  2180. dnl  where _GLOBAL_OFFSET_TABLE_ results in a bfd error, since there's no
  2181. dnl  GOT etc in PE object files.
  2182. dnl
  2183. dnl  This test is used before the object file extension has been determined,
  2184. dnl  so we force output to conftest.o.  Using -o with -c is not portable,
  2185. dnl  but we think all x86 compilers will accept -o with -c, certainly gcc
  2186. dnl  does.
  2187. dnl
  2188. dnl  -fPIC is hard coded here, because this test is for use before libtool
  2189. dnl  has established the pic options.  It's right for gcc, but perhaps not
  2190. dnl  other compilers.
  2191. AC_DEFUN([GMP_ASM_X86_GOT_EAX_OK],
  2192. [echo "Testing gas GOT with eax good" >&AC_FD_CC
  2193. cat >conftest.awk <<EOF
  2194. [BEGIN {
  2195.   want[0]  = "001"
  2196.   want[1]  = "043"
  2197.   want[2]  = "105"
  2198.   want[3]  = "147"
  2199.   want[4]  = "211"
  2200.   want[5]  = "253"
  2201.   want[6]  = "315"
  2202.   want[7]  = "357"
  2203.   want[8]  = "005"
  2204.   want[9]  = "002"
  2205.   want[10] = "000"
  2206.   want[11] = "000"
  2207.   want[12] = "000"
  2208.   want[13] = "376"
  2209.   want[14] = "334"
  2210.   want[15] = "272"
  2211.   want[16] = "230"
  2212.   want[17] = "166"
  2213.   want[18] = "124"
  2214.   want[19] = "062"
  2215.   want[20] = "020"
  2216.   result = "yes"
  2217. }
  2218. {
  2219.   for (f = 2; f <= NF; f++)
  2220.     {
  2221.       for (i = 0; i < 20; i++)
  2222.         got[i] = got[i+1];
  2223.       got[20] = $f;
  2224.       found = 1
  2225.       for (i = 0; i < 21; i++)
  2226.         if (got[i] != want[i])
  2227.           {
  2228.             found = 0
  2229.             break
  2230.           }
  2231.       if (found)
  2232.         {
  2233.           result = "no"
  2234.           exit
  2235.         }
  2236.     }
  2237. }
  2238. END {
  2239.   print result
  2240. }
  2241. ]EOF
  2242. cat >conftest.s <<EOF
  2243. [ .text
  2244. .byte 1, 35, 69, 103, 137, 171, 205, 239
  2245. addl $_GLOBAL_OFFSET_TABLE_, %eax
  2246. .byte 254, 220, 186, 152, 118, 84, 50, 16
  2247. ]EOF
  2248. tmp_got_good=yes
  2249. gmp_compile="$1 -fPIC -o conftest.o -c conftest.s >&AC_FD_CC 2>&1"
  2250. if AC_TRY_EVAL(gmp_compile); then
  2251.   tmp_got_good=`od -b conftest.o | $AWK -f conftest.awk`
  2252. fi
  2253. rm -f conftest.*
  2254. echo "Result: $tmp_got_good" >&AC_FD_CC
  2255. if test "$tmp_got_good" = no; then
  2256.   ifelse([$3],,:,[$3])
  2257. else
  2258.   ifelse([$2],,:,[$2])
  2259. fi
  2260. ])
  2261. dnl  GMP_ASM_X86_MMX([ACTION-IF-YES][,ACTION-IF-NO])
  2262. dnl  -----------------------------------------------
  2263. dnl  Determine whether the assembler supports MMX instructions.
  2264. dnl
  2265. dnl  This macro is wanted before GMP_ASM_TEXT, so ".text" is hard coded
  2266. dnl  here.  ".text" is believed to be correct on all x86 systems.  Actually
  2267. dnl  ".text" probably isn't needed at all, at least for just checking
  2268. dnl  instruction syntax.
  2269. dnl
  2270. dnl  "movq %mm0, %mm1" should assemble to "0f 6f c8", but Solaris 2.6 and
  2271. dnl  2.7 wrongly assemble it to "0f 6f c1" (that being the reverse "movq
  2272. dnl  %mm1, %mm0").  It seems more trouble than it's worth to work around
  2273. dnl  this in the code, so just detect and reject.
  2274. AC_DEFUN([GMP_ASM_X86_MMX],
  2275. [AC_CACHE_CHECK([if the assembler knows about MMX instructions],
  2276. gmp_cv_asm_x86_mmx,
  2277. [GMP_TRY_ASSEMBLE(
  2278. [ .text
  2279. movq %mm0, %mm1],
  2280. [gmp_cv_asm_x86_mmx=yes
  2281. case $host in
  2282. *-*-solaris*)
  2283.   if (dis conftest.$OBJEXT >conftest.out) 2>/dev/null; then
  2284.     if grep "0f 6f c1" conftest.out >/dev/null; then
  2285.       gmp_cv_asm_x86_mmx=movq-bug
  2286.     fi
  2287.   else
  2288.     AC_MSG_WARN(["dis" not available to check for "as" movq bug])
  2289.   fi
  2290. esac],
  2291. [gmp_cv_asm_x86_mmx=no])])
  2292. case $gmp_cv_asm_x86_mmx in
  2293. movq-bug)
  2294.   AC_MSG_WARN([+----------------------------------------------------------])
  2295.   AC_MSG_WARN([| WARNING WARNING WARNING])
  2296.   AC_MSG_WARN([| Host CPU has MMX code, but the assembler])
  2297.   AC_MSG_WARN([|     $CCAS $CFLAGS $CPPFLAGS])
  2298.   AC_MSG_WARN([| has the Solaris 2.6 and 2.7 bug where register to register])
  2299.   AC_MSG_WARN([| movq operands are reversed.])
  2300.   AC_MSG_WARN([| Non-MMX replacements will be used.])
  2301.   AC_MSG_WARN([| This will be an inferior build.])
  2302.   AC_MSG_WARN([+----------------------------------------------------------])
  2303.   ;;
  2304. no)
  2305.   AC_MSG_WARN([+----------------------------------------------------------])
  2306.   AC_MSG_WARN([| WARNING WARNING WARNING])
  2307.   AC_MSG_WARN([| Host CPU has MMX code, but it can't be assembled by])
  2308.   AC_MSG_WARN([|     $CCAS $CFLAGS $CPPFLAGS])
  2309.   AC_MSG_WARN([| Non-MMX replacements will be used.])
  2310.   AC_MSG_WARN([| This will be an inferior build.])
  2311.   AC_MSG_WARN([+----------------------------------------------------------])
  2312.   ;;
  2313. esac
  2314. if test "$gmp_cv_asm_x86_mmx" = yes; then
  2315.   ifelse([$1],,:,[$1])
  2316. else
  2317.   ifelse([$2],,:,[$2])
  2318. fi
  2319. ])
  2320. dnl  GMP_ASM_X86_SHLDL_CL
  2321. dnl  --------------------
  2322. AC_DEFUN([GMP_ASM_X86_SHLDL_CL],
  2323. [AC_REQUIRE([GMP_ASM_TEXT])
  2324. AC_CACHE_CHECK([if the assembler takes cl with shldl],
  2325. gmp_cv_asm_x86_shldl_cl,
  2326. [GMP_TRY_ASSEMBLE(
  2327. [ $gmp_cv_asm_text
  2328. shldl %cl, %eax, %ebx],
  2329.   gmp_cv_asm_x86_shldl_cl=yes,
  2330.   gmp_cv_asm_x86_shldl_cl=no)
  2331. ])
  2332. if test "$gmp_cv_asm_x86_shldl_cl" = "yes"; then
  2333.   GMP_DEFINE(WANT_SHLDL_CL,1)
  2334. else
  2335.   GMP_DEFINE(WANT_SHLDL_CL,0)
  2336. fi
  2337. ])
  2338. dnl  GMP_ASM_X86_SSE2([ACTION-IF-YES][,ACTION-IF-NO])
  2339. dnl  ------------------------------------------------
  2340. dnl  Determine whether the assembler supports SSE2 instructions.
  2341. dnl
  2342. dnl  This macro is wanted before GMP_ASM_TEXT, so ".text" is hard coded
  2343. dnl  here.  ".text" is believed to be correct on all x86 systems, certainly
  2344. dnl  it's all GMP_ASM_TEXT gives currently.  Actually ".text" probably isn't
  2345. dnl  needed at all, at least for just checking instruction syntax.
  2346. AC_DEFUN([GMP_ASM_X86_SSE2],
  2347. [AC_CACHE_CHECK([if the assembler knows about SSE2 instructions],
  2348. gmp_cv_asm_x86_sse2,
  2349. [GMP_TRY_ASSEMBLE(
  2350. [ .text
  2351. paddq %mm0, %mm1],
  2352.   [gmp_cv_asm_x86_sse2=yes],
  2353.   [gmp_cv_asm_x86_sse2=no])
  2354. ])
  2355. case $gmp_cv_asm_x86_sse2 in
  2356. yes)
  2357.   ifelse([$1],,:,[$1])
  2358.   ;;
  2359. *)
  2360.   AC_MSG_WARN([+----------------------------------------------------------])
  2361.   AC_MSG_WARN([| WARNING WARNING WARNING])
  2362.   AC_MSG_WARN([| Host CPU has SSE2 code, but it can't be assembled by])
  2363.   AC_MSG_WARN([|     $CCAS $CFLAGS $CPPFLAGS])
  2364.   AC_MSG_WARN([| Non-SSE2 replacements will be used.])
  2365.   AC_MSG_WARN([| This will be an inferior build.])
  2366.   AC_MSG_WARN([+----------------------------------------------------------])
  2367.   ifelse([$2],,:,[$2])
  2368.   ;;
  2369. esac
  2370. ])
  2371. dnl  GMP_ASM_X86_MCOUNT
  2372. dnl  ------------------
  2373. dnl  Find out how to call mcount for profiling on an x86 system.
  2374. dnl
  2375. dnl  A dummy function is compiled and the ".s" output examined.  The pattern
  2376. dnl  matching might be a bit fragile, but should work at least with gcc on
  2377. dnl  sensible systems.  Certainly it's better than hard coding a table of
  2378. dnl  conventions.
  2379. dnl
  2380. dnl  For non-PIC, any ".data" is taken to mean a counter might be passed.
  2381. dnl  It's assumed a movl will set it up, and the right register is taken
  2382. dnl  from that movl.  Any movl involving %esp is ignored (a frame pointer
  2383. dnl  setup normally).
  2384. dnl
  2385. dnl  For PIC, any ".data" is similarly interpreted, but a GOTOFF identifies
  2386. dnl  the line setting up the right register.
  2387. dnl
  2388. dnl  In both cases a line with "mcount" identifies the call and that line is
  2389. dnl  used literally.
  2390. dnl
  2391. dnl  On some systems (eg. FreeBSD 3.5) gcc emits ".data" but doesn't use it,
  2392. dnl  so it's not an error to have .data but then not find a register.
  2393. dnl
  2394. dnl  Variations in mcount conventions on different x86 systems can be found
  2395. dnl  in gcc config/i386.  mcount can have a "_" prefix or be .mcount or
  2396. dnl  _mcount_ptr, and for PIC it can be called through a GOT entry, or via
  2397. dnl  the PLT.  If a pointer to a counter is required it's passed in %eax or
  2398. dnl  %edx.
  2399. dnl
  2400. dnl  Flags to specify PIC are taken from $lt_prog_compiler_pic set by
  2401. dnl  AC_PROG_LIBTOOL.
  2402. dnl
  2403. dnl  Enhancement: Cache the values determined here. But what's the right way
  2404. dnl  to get two variables (mcount_nonpic_reg and mcount_nonpic_call say) set
  2405. dnl  from one block of commands?
  2406. AC_DEFUN([GMP_ASM_X86_MCOUNT],
  2407. [AC_REQUIRE([AC_ENABLE_SHARED])
  2408. AC_REQUIRE([AC_PROG_LIBTOOL])
  2409. AC_MSG_CHECKING([how to call x86 mcount])
  2410. cat >conftest.c <<EOF
  2411. foo(){bar();}
  2412. EOF
  2413. if test "$enable_static" = yes; then
  2414.   gmp_asmout_compile="$CC $CFLAGS $CPPFLAGS -S conftest.c 1>&AC_FD_CC"
  2415.   if AC_TRY_EVAL(gmp_asmout_compile); then
  2416.     if grep '.data' conftest.s >/dev/null; then
  2417.       mcount_nonpic_reg=`sed -n ['/esp/!s/.*movl.*,(%[a-z]*).*$/1/p'] conftest.s`
  2418.     else
  2419.       mcount_nonpic_reg=
  2420.     fi
  2421.     mcount_nonpic_call=`grep 'call.*mcount' conftest.s`
  2422.     if test -z "$mcount_nonpic_call"; then
  2423.       AC_MSG_ERROR([Cannot find mcount call for non-PIC])
  2424.     fi
  2425.   else
  2426.     AC_MSG_ERROR([Cannot compile test program for non-PIC])
  2427.   fi
  2428. fi
  2429. if test "$enable_shared" = yes; then
  2430.   gmp_asmout_compile="$CC $CFLAGS $CPPFLAGS $lt_prog_compiler_pic -S conftest.c 1>&AC_FD_CC"
  2431.   if AC_TRY_EVAL(gmp_asmout_compile); then
  2432.     if grep '.data' conftest.s >/dev/null; then
  2433.       case $lt_prog_compiler_pic in
  2434.         *-DDLL_EXPORT*)
  2435.           # Windows DLLs have non-PIC style mcount
  2436.           mcount_pic_reg=`sed -n ['/esp/!s/.*movl.*,(%[a-z]*).*$/1/p'] conftest.s`
  2437.           ;;
  2438.         *)
  2439.           mcount_pic_reg=`sed -n ['s/.*GOTOFF.*,(%[a-z]*).*$/1/p'] conftest.s`
  2440.           ;;
  2441.       esac
  2442.     else
  2443.       mcount_pic_reg=
  2444.     fi
  2445.     mcount_pic_call=`grep 'call.*mcount' conftest.s`
  2446.     if test -z "$mcount_pic_call"; then
  2447.       AC_MSG_ERROR([Cannot find mcount call for PIC])
  2448.     fi
  2449.   else
  2450.     AC_MSG_ERROR([Cannot compile test program for PIC])
  2451.   fi
  2452. fi
  2453. GMP_DEFINE_RAW(["define(<MCOUNT_NONPIC_REG>, <`$mcount_nonpic_reg'>)"])
  2454. GMP_DEFINE_RAW(["define(<MCOUNT_NONPIC_CALL>,<`$mcount_nonpic_call'>)"])
  2455. GMP_DEFINE_RAW(["define(<MCOUNT_PIC_REG>,    <`$mcount_pic_reg'>)"])
  2456. GMP_DEFINE_RAW(["define(<MCOUNT_PIC_CALL>,   <`$mcount_pic_call'>)"])
  2457. rm -f conftest.*
  2458. AC_MSG_RESULT([determined])
  2459. ])
  2460. dnl  GMP_ASM_IA64_ALIGN_OK
  2461. dnl  ---------------------
  2462. dnl  Determine whether .align correctly pads with nop instructions in a text
  2463. dnl  segment.
  2464. dnl
  2465. dnl  gas 2.14 and earlier byte swaps its padding bundle on big endian
  2466. dnl  systems, which is incorrect (endianness only changes data).  What
  2467. dnl  should be "nop.m / nop.f / nop.i" comes out as "break" instructions.
  2468. dnl
  2469. dnl  The test here detects the bad case, and assumes anything else is ok
  2470. dnl  (there are many sensible nop bundles, so it'd be impractical to try to
  2471. dnl  match everything good).
  2472. AC_DEFUN([GMP_ASM_IA64_ALIGN_OK],
  2473. [AC_CACHE_CHECK([whether assembler .align padding is good],
  2474. gmp_cv_asm_ia64_align_ok,
  2475. [cat >conftest.awk <<EOF
  2476. [BEGIN {
  2477.   want[0]  = "011"
  2478.   want[1]  = "160"
  2479.   want[2]  = "074"
  2480.   want[3]  = "040"
  2481.   want[4]  = "000"
  2482.   want[5]  = "040"
  2483.   want[6]  = "020"
  2484.   want[7]  = "221"
  2485.   want[8]  = "114"
  2486.   want[9]  = "000"
  2487.   want[10] = "100"
  2488.   want[11] = "200"
  2489.   want[12] = "122"
  2490.   want[13] = "261"
  2491.   want[14] = "000"
  2492.   want[15] = "200"
  2493.   want[16] = "000"
  2494.   want[17] = "004"
  2495.   want[18] = "000"
  2496.   want[19] = "000"
  2497.   want[20] = "000"
  2498.   want[21] = "000"
  2499.   want[22] = "002"
  2500.   want[23] = "000"
  2501.   want[24] = "000"
  2502.   want[25] = "000"
  2503.   want[26] = "000"
  2504.   want[27] = "001"
  2505.   want[28] = "000"
  2506.   want[29] = "000"
  2507.   want[30] = "000"
  2508.   want[31] = "014"
  2509.   want[32] = "011"
  2510.   want[33] = "270"
  2511.   want[34] = "140"
  2512.   want[35] = "062"
  2513.   want[36] = "000"
  2514.   want[37] = "040"
  2515.   want[38] = "240"
  2516.   want[39] = "331"
  2517.   want[40] = "160"
  2518.   want[41] = "000"
  2519.   want[42] = "100"
  2520.   want[43] = "240"
  2521.   want[44] = "343"
  2522.   want[45] = "371"
  2523.   want[46] = "000"
  2524.   want[47] = "200"
  2525.   result = "yes"
  2526. }
  2527. {
  2528.   for (f = 2; f <= NF; f++)
  2529.     {
  2530.       for (i = 0; i < 47; i++)
  2531.         got[i] = got[i+1];
  2532.       got[47] = $f;
  2533.       found = 1
  2534.       for (i = 0; i < 48; i++)
  2535.         if (got[i] != want[i])
  2536.           {
  2537.             found = 0
  2538.             break
  2539.           }
  2540.       if (found)
  2541.         {
  2542.           result = "no"
  2543.           exit
  2544.         }
  2545.     }
  2546. }
  2547. END {
  2548.   print result
  2549. }
  2550. ]EOF
  2551. GMP_TRY_ASSEMBLE(
  2552. [ .text
  2553. .align 32
  2554. { .mmi; add r14 = r15, r16
  2555. add r17 = r18, r19
  2556. add r20 = r21, r22 ;; }
  2557. .align 32
  2558. { .mmi; add r23 = r24, r25
  2559. add r26 = r27, r28
  2560. add r29 = r30, r31 ;; }
  2561. ],
  2562.   [gmp_cv_asm_ia64_align_ok=`od -b conftest.$OBJEXT | $AWK -f conftest.awk`],
  2563.   [AC_MSG_WARN([oops, cannot compile test program])
  2564.    gmp_cv_asm_ia64_align_ok=yes])
  2565. ])
  2566. GMP_DEFINE_RAW(["define(<IA64_ALIGN_OK>, <`$gmp_cv_asm_ia64_align_ok'>)"])
  2567. ])
  2568. dnl  GMP_ASM_M68K_INSTRUCTION
  2569. dnl  ------------------------
  2570. dnl  Not sure if ".l" and "%" are independent settings, but it doesn't hurt
  2571. dnl  to try all four possibilities.  Note that the % ones must be first, so
  2572. dnl  "d0" won't be interpreted as a label.
  2573. dnl
  2574. dnl  gas 1.92.3 on NetBSD 1.4 needs to be tested with a two operand
  2575. dnl  instruction.  It takes registers without "%", but a single operand
  2576. dnl  "clrl %d0" only gives a warning, not an error.
  2577. AC_DEFUN([GMP_ASM_M68K_INSTRUCTION],
  2578. [AC_REQUIRE([GMP_ASM_TEXT])
  2579. AC_CACHE_CHECK([assembler instruction and register style],
  2580. gmp_cv_asm_m68k_instruction,
  2581. [for i in "addl %d0,%d1" "add.l %d0,%d1" "addl d0,d1" "add.l d0,d1"; do
  2582.   GMP_TRY_ASSEMBLE(
  2583.     [ $gmp_cv_asm_text
  2584. $i],
  2585.     [gmp_cv_asm_m68k_instruction=$i
  2586.     rm -f conftest*
  2587.     break])
  2588. done
  2589. if test -z "$gmp_cv_asm_m68k_instruction"; then
  2590.   AC_MSG_ERROR([cannot determine assembler instruction and register style])
  2591. fi
  2592. ])
  2593. case $gmp_cv_asm_m68k_instruction in
  2594. "addl d0,d1")    want_dot_size=no;  want_register_percent=no  ;;
  2595. "addl %d0,%d1")  want_dot_size=no;  want_register_percent=yes ;;
  2596. "add.l d0,d1")   want_dot_size=yes; want_register_percent=no  ;;
  2597. "add.l %d0,%d1") want_dot_size=yes; want_register_percent=yes ;;
  2598. *) AC_MSG_ERROR([oops, unrecognised instruction and register style]) ;;
  2599. esac
  2600. GMP_DEFINE_RAW(["define(<WANT_REGISTER_PERCENT>, <`$want_register_percent'>)"])
  2601. GMP_DEFINE_RAW(["define(<WANT_DOT_SIZE>, <`$want_dot_size'>)"])
  2602. ])
  2603. dnl  GMP_ASM_M68K_ADDRESSING
  2604. dnl  -----------------------
  2605. AC_DEFUN([GMP_ASM_M68K_ADDRESSING],
  2606. [AC_REQUIRE([GMP_ASM_TEXT])
  2607. AC_REQUIRE([GMP_ASM_M68K_INSTRUCTION])
  2608. AC_CACHE_CHECK([assembler addressing style],
  2609. gmp_cv_asm_m68k_addressing,
  2610. [case $gmp_cv_asm_m68k_instruction in
  2611. addl*)  movel=movel ;;
  2612. add.l*) movel=move.l ;;
  2613. *) AC_MSG_ERROR([oops, unrecognised gmp_cv_asm_m68k_instruction]) ;;
  2614. esac
  2615. case $gmp_cv_asm_m68k_instruction in
  2616. *"%d0,%d1") dreg=%d0; areg=%a0 ;;
  2617. *"d0,d1")   dreg=d0;  areg=a0  ;;
  2618. *) AC_MSG_ERROR([oops, unrecognised gmp_cv_asm_m68k_instruction]) ;;
  2619. esac
  2620. GMP_TRY_ASSEMBLE(
  2621. [ $gmp_cv_asm_text
  2622. $movel $dreg, $areg@-],
  2623.   [gmp_cv_asm_m68k_addressing=mit],
  2624. [GMP_TRY_ASSEMBLE(
  2625. [ $gmp_cv_asm_text
  2626. $movel $dreg, -($areg)],
  2627.   [gmp_cv_asm_m68k_addressing=motorola],
  2628. [AC_MSG_ERROR([cannot determine assembler addressing style])])])
  2629. ])
  2630. GMP_DEFINE_RAW(["define(<WANT_ADDRESSING>, <`$gmp_cv_asm_m68k_addressing'>)"])
  2631. ])
  2632. dnl  GMP_ASM_M68K_BRANCHES
  2633. dnl  ---------------------
  2634. dnl  "bra" is the standard branch instruction.  "jra" or "jbra" are
  2635. dnl  preferred where available, since on gas for instance they give a
  2636. dnl  displacement only as big as it needs to be, whereas "bra" is always
  2637. dnl  16-bits.  This applies to the conditional branches "bcc" etc too.
  2638. dnl  However "dbcc" etc on gas are already only as big as they need to be.
  2639. AC_DEFUN([GMP_ASM_M68K_BRANCHES],
  2640. [AC_REQUIRE([GMP_ASM_TEXT])
  2641. AC_CACHE_CHECK([assembler shortest branches],
  2642. gmp_cv_asm_m68k_branches,
  2643. [for i in jra jbra bra; do
  2644.   GMP_TRY_ASSEMBLE(
  2645. [ $gmp_cv_asm_text
  2646. foo$gmp_cv_asm_label_suffix
  2647. $i foo],
  2648.   [gmp_cv_asm_m68k_branches=$i
  2649.   rm -f conftest*
  2650.   break])
  2651. done
  2652. if test -z "$gmp_cv_asm_m68k_branches"; then
  2653.   AC_MSG_ERROR([cannot determine assembler branching style])
  2654. fi
  2655. ])
  2656. GMP_DEFINE_RAW(["define(<WANT_BRANCHES>, <`$gmp_cv_asm_m68k_branches'>)"])
  2657. ])
  2658. dnl  GMP_ASM_POWERPC_PIC_ALWAYS
  2659. dnl  --------------------------
  2660. dnl  Determine whether PIC is the default compiler output.
  2661. dnl
  2662. dnl  SVR4 style "foo@ha" addressing is interpreted as non-PIC, and anything
  2663. dnl  else is assumed to require PIC always (Darwin or AIX).  SVR4 is the
  2664. dnl  only non-PIC addressing syntax the asm files have at the moment anyway.
  2665. dnl
  2666. dnl  Libtool does this by taking "*-*-aix* | *-*-darwin* | *-*-rhapsody*" to
  2667. dnl  mean PIC always, but it seems more reliable to grep the compiler
  2668. dnl  output.
  2669. dnl
  2670. dnl The next paragraph is untrue for Tiger.  Was it ever true?  For tiger,
  2671. dnl "cc -fast" makes non-PIC the default (and the binaries do run).
  2672. dnl  On Darwin "cc -static" is non-PIC with syntax "ha16(_foo)", but that's
  2673. dnl  apparently only for use in the kernel, which we're not attempting to
  2674. dnl  target at the moment, so don't look for that.
  2675. AC_DEFUN([GMP_ASM_POWERPC_PIC_ALWAYS],
  2676. [AC_REQUIRE([AC_PROG_CC])
  2677. AC_CACHE_CHECK([whether compiler output is PIC by default],
  2678.                gmp_cv_asm_powerpc_pic,
  2679. [gmp_cv_asm_powerpc_pic=yes
  2680. cat >conftest.c <<EOF
  2681. int foo;
  2682. int *bar() { return &foo; }
  2683. EOF
  2684. echo "Test program:" >&AC_FD_CC
  2685. cat conftest.c >&AC_FD_CC
  2686. gmp_compile="$CC $CFLAGS $CPPFLAGS -S conftest.c >&AC_FD_CC"
  2687. if AC_TRY_EVAL(gmp_compile); then
  2688.   echo "Compiler output:" >&AC_FD_CC
  2689.   cat conftest.s >&AC_FD_CC
  2690.   if grep 'foo@ha' conftest.s >/dev/null 2>&AC_FD_CC; then
  2691.     gmp_cv_asm_powerpc_pic=no
  2692.   fi
  2693.   if grep 'ha16(_foo)' conftest.s >/dev/null 2>&AC_FD_CC; then
  2694.     gmp_cv_asm_powerpc_pic=no
  2695.   fi
  2696. fi
  2697. rm -f conftest*
  2698. ])
  2699. GMP_DEFINE_RAW(["define(<PIC_ALWAYS>,<$gmp_cv_asm_powerpc_pic>)"])
  2700. ])
  2701. dnl  GMP_ASM_POWERPC_R_REGISTERS
  2702. dnl  ---------------------------
  2703. dnl  Determine whether the assembler takes powerpc registers with an "r" as
  2704. dnl  in "r6", or as plain "6".  The latter is standard, but NeXT, Rhapsody,
  2705. dnl  and MacOS-X require the "r" forms.
  2706. dnl
  2707. dnl  See also mpn/powerpc32/powerpc-defs.m4 which uses the result of this
  2708. dnl  test.
  2709. AC_DEFUN([GMP_ASM_POWERPC_R_REGISTERS],
  2710. [AC_REQUIRE([GMP_ASM_TEXT])
  2711. AC_CACHE_CHECK([if the assembler needs r on registers],
  2712.                gmp_cv_asm_powerpc_r_registers,
  2713. [GMP_TRY_ASSEMBLE(
  2714. [ $gmp_cv_asm_text
  2715. mtctr 6],
  2716. [gmp_cv_asm_powerpc_r_registers=no],
  2717. [GMP_TRY_ASSEMBLE(
  2718. [ $gmp_cv_asm_text
  2719. mtctr r6],
  2720. [gmp_cv_asm_powerpc_r_registers=yes],
  2721. [AC_MSG_ERROR([neither "mtctr 6" nor "mtctr r6" works])])])])
  2722. GMP_DEFINE_RAW(["define(<WANT_R_REGISTERS>,<$gmp_cv_asm_powerpc_r_registers>)"])
  2723. ])
  2724. dnl  GMP_ASM_SPARC_REGISTER
  2725. dnl  ----------------------
  2726. dnl  Determine whether the assembler accepts the ".register" directive.
  2727. dnl  Old versions of solaris "as" don't.
  2728. dnl
  2729. dnl  See also mpn/sparc32/sparc-defs.m4 which uses the result of this test.
  2730. AC_DEFUN([GMP_ASM_SPARC_REGISTER],
  2731. [AC_REQUIRE([GMP_ASM_TEXT])
  2732. AC_CACHE_CHECK([if the assembler accepts ".register"],
  2733.                gmp_cv_asm_sparc_register,
  2734. [GMP_TRY_ASSEMBLE(
  2735. [ $gmp_cv_asm_text
  2736. .register %g2,#scratch
  2737. ],
  2738. [gmp_cv_asm_sparc_register=yes],
  2739. [gmp_cv_asm_sparc_register=no])])
  2740. GMP_DEFINE_RAW(["define(<HAVE_REGISTER>,<$gmp_cv_asm_sparc_register>)"])
  2741. ])
  2742. dnl  GMP_C_ATTRIBUTE_CONST
  2743. dnl  ---------------------
  2744. AC_DEFUN([GMP_C_ATTRIBUTE_CONST],
  2745. [AC_CACHE_CHECK([whether gcc __attribute__ ((const)) works],
  2746.                 gmp_cv_c_attribute_const,
  2747. [AC_TRY_COMPILE([int foo (int x) __attribute__ ((const));], ,
  2748.   gmp_cv_c_attribute_const=yes, gmp_cv_c_attribute_const=no)
  2749. ])
  2750. if test $gmp_cv_c_attribute_const = yes; then
  2751.   AC_DEFINE(HAVE_ATTRIBUTE_CONST, 1,
  2752.   [Define to 1 if the compiler accepts gcc style __attribute__ ((const))])
  2753. fi
  2754. ])
  2755. dnl  GMP_C_ATTRIBUTE_MALLOC
  2756. dnl  ----------------------
  2757. dnl  gcc 2.95.x accepts __attribute__ ((malloc)) but with a warning that
  2758. dnl  it's ignored.  Pretend it doesn't exist in this case, to avoid that
  2759. dnl  warning.
  2760. AC_DEFUN([GMP_C_ATTRIBUTE_MALLOC],
  2761. [AC_CACHE_CHECK([whether gcc __attribute__ ((malloc)) works],
  2762.                 gmp_cv_c_attribute_malloc,
  2763. [cat >conftest.c <<EOF
  2764. void *foo (int x) __attribute__ ((malloc));
  2765. EOF
  2766. gmp_compile="$CC $CFLAGS $CPPFLAGS -c conftest.c >conftest.out 2>&1"
  2767. if AC_TRY_EVAL(gmp_compile); then
  2768.   if grep "attribute directive ignored" conftest.out >/dev/null; then
  2769.     gmp_cv_c_attribute_malloc=no
  2770.   else
  2771.     gmp_cv_c_attribute_malloc=yes
  2772.   fi
  2773. else
  2774.   gmp_cv_c_attribute_malloc=no
  2775. fi
  2776. cat conftest.out >&AC_FD_CC
  2777. rm -f conftest*
  2778. ])
  2779. if test $gmp_cv_c_attribute_malloc = yes; then
  2780.   AC_DEFINE(HAVE_ATTRIBUTE_MALLOC, 1,
  2781.   [Define to 1 if the compiler accepts gcc style __attribute__ ((malloc))])
  2782. fi
  2783. ])
  2784. dnl  GMP_C_ATTRIBUTE_MODE
  2785. dnl  --------------------
  2786. dnl  Introduced in gcc 2.2, but perhaps not in all Apple derived versions.
  2787. AC_DEFUN([GMP_C_ATTRIBUTE_MODE],
  2788. [AC_CACHE_CHECK([whether gcc __attribute__ ((mode (XX))) works],
  2789.                 gmp_cv_c_attribute_mode,
  2790. [AC_TRY_COMPILE([typedef int SItype __attribute__ ((mode (SI)));], ,
  2791.   gmp_cv_c_attribute_mode=yes, gmp_cv_c_attribute_mode=no)
  2792. ])
  2793. if test $gmp_cv_c_attribute_mode = yes; then
  2794.   AC_DEFINE(HAVE_ATTRIBUTE_MODE, 1,
  2795.   [Define to 1 if the compiler accepts gcc style __attribute__ ((mode (XX)))])
  2796. fi
  2797. ])
  2798. dnl  GMP_C_ATTRIBUTE_NORETURN
  2799. dnl  ------------------------
  2800. AC_DEFUN([GMP_C_ATTRIBUTE_NORETURN],
  2801. [AC_CACHE_CHECK([whether gcc __attribute__ ((noreturn)) works],
  2802.                 gmp_cv_c_attribute_noreturn,
  2803. [AC_TRY_COMPILE([void foo (int x) __attribute__ ((noreturn));], ,
  2804.   gmp_cv_c_attribute_noreturn=yes, gmp_cv_c_attribute_noreturn=no)
  2805. ])
  2806. if test $gmp_cv_c_attribute_noreturn = yes; then
  2807.   AC_DEFINE(HAVE_ATTRIBUTE_NORETURN, 1,
  2808.   [Define to 1 if the compiler accepts gcc style __attribute__ ((noreturn))])
  2809. fi
  2810. ])
  2811. dnl  GMP_C_DOUBLE_FORMAT
  2812. dnl  -------------------
  2813. dnl  Determine the floating point format.
  2814. dnl
  2815. dnl  The object file is grepped, in order to work when cross compiling.  A
  2816. dnl  start and end sequence is included to avoid false matches, and
  2817. dnl  allowance is made for the desired data crossing an "od -b" line
  2818. dnl  boundary.  The test number is a small integer so it should appear
  2819. dnl  exactly, no rounding or truncation etc.
  2820. dnl
  2821. dnl  "od -b", incidentally, is supported even by Unix V7, and the awk script
  2822. dnl  used doesn't have functions or anything, so even an "old" awk should
  2823. dnl  suffice.
  2824. AC_DEFUN([GMP_C_DOUBLE_FORMAT],
  2825. [AC_REQUIRE([AC_PROG_CC])
  2826. AC_REQUIRE([AC_PROG_AWK])
  2827. AC_CACHE_CHECK([format of `double' floating point],
  2828.                 gmp_cv_c_double_format,
  2829. [gmp_cv_c_double_format=unknown
  2830. cat >conftest.c <<EOF
  2831. [struct {
  2832.   char    before[8];
  2833.   double  x;
  2834.   char    after[8];
  2835. } foo = {
  2836.   { '01', '43', '105', '147', '211', '253', '315', '357' },
  2837.   -123456789.0,
  2838.   { '376', '334', '272', '230', '166', '124', '62', '20' },
  2839. };]
  2840. EOF
  2841. gmp_compile="$CC $CFLAGS $CPPFLAGS -c conftest.c >&AC_FD_CC 2>&1"
  2842. if AC_TRY_EVAL(gmp_compile); then
  2843. cat >conftest.awk <<EOF
  2844. [
  2845. BEGIN {
  2846.   found = 0
  2847. }
  2848. {
  2849.   for (f = 2; f <= NF; f++)
  2850.     {
  2851.       for (i = 0; i < 23; i++)
  2852.         got[i] = got[i+1];
  2853.       got[23] = $f;
  2854.       # match the special begin and end sequences
  2855.       if (got[0] != "001") continue
  2856.       if (got[1] != "043") continue
  2857.       if (got[2] != "105") continue
  2858.       if (got[3] != "147") continue
  2859.       if (got[4] != "211") continue
  2860.       if (got[5] != "253") continue
  2861.       if (got[6] != "315") continue
  2862.       if (got[7] != "357") continue
  2863.       if (got[16] != "376") continue
  2864.       if (got[17] != "334") continue
  2865.       if (got[18] != "272") continue
  2866.       if (got[19] != "230") continue
  2867.       if (got[20] != "166") continue
  2868.       if (got[21] != "124") continue
  2869.       if (got[22] != "062") continue
  2870.       if (got[23] != "020") continue
  2871.       saw = " (" got[8] " " got[9] " " got[10] " " got[11] " " got[12] " " got[13] " " got[14] " " got[15] ")"
  2872.       if (got[8]  == "000" &&  
  2873.           got[9]  == "000" &&  
  2874.           got[10] == "000" &&  
  2875.           got[11] == "124" &&  
  2876.           got[12] == "064" &&  
  2877.           got[13] == "157" &&  
  2878.           got[14] == "235" &&  
  2879.           got[15] == "301")
  2880.         {
  2881.           print "IEEE little endian"
  2882.           found = 1
  2883.           exit
  2884.         }
  2885.       # Little endian with the two 4-byte halves swapped, as used by ARM
  2886.       # when the chip is in little endian mode.
  2887.       #
  2888.       if (got[8]  == "064" &&  
  2889.           got[9]  == "157" &&  
  2890.           got[10] == "235" &&  
  2891.           got[11] == "301" &&  
  2892.           got[12] == "000" &&  
  2893.           got[13] == "000" &&  
  2894.           got[14] == "000" &&  
  2895.           got[15] == "124")
  2896.         {
  2897.           print "IEEE little endian, swapped halves"
  2898.           found = 1
  2899.           exit
  2900.         }
  2901.       # gcc 2.95.4 on one GNU/Linux ARM system was seen generating 000 in
  2902.       # the last byte, whereas 124 is correct.  Not sure where the bug
  2903.       # actually lies, but a running program didn't seem to get a full
  2904.       # mantissa worth of working bits.
  2905.       #
  2906.       # We match this case explicitly so we can give a nice result message,
  2907.       # but we deliberately exclude it from the normal IEEE double setups
  2908.       # since it's too broken.
  2909.       #
  2910.       if (got[8]  == "064" &&  
  2911.           got[9]  == "157" &&  
  2912.           got[10] == "235" &&  
  2913.           got[11] == "301" &&  
  2914.           got[12] == "000" &&  
  2915.           got[13] == "000" &&  
  2916.           got[14] == "000" &&  
  2917.           got[15] == "000")
  2918.         {
  2919.           print "bad ARM software floats"
  2920.           found = 1
  2921.           exit
  2922.         }
  2923.       if (got[8]  == "301" &&  
  2924.           got[9]  == "235" &&  
  2925.           got[10] == "157" &&  
  2926.           got[11] == "064" &&  
  2927.           got[12] == "124" &&  
  2928.           got[13] == "000" &&  
  2929.           got[14] == "000" &&  
  2930.   got[15] == "000")
  2931.         {
  2932.           print "IEEE big endian"
  2933.           found = 1
  2934.           exit
  2935.         }
  2936.       if (got[8]  == "353" &&  
  2937.           got[9]  == "315" &&  
  2938.           got[10] == "242" &&  
  2939.           got[11] == "171" &&  
  2940.           got[12] == "000" &&  
  2941.           got[13] == "240" &&  
  2942.           got[14] == "000" &&  
  2943.           got[15] == "000")
  2944.         {
  2945.           print "VAX D"
  2946.           found = 1
  2947.           exit
  2948.         }
  2949.       if (got[8]  == "275" &&  
  2950.           got[9]  == "301" &&  
  2951.           got[10] == "064" &&  
  2952.           got[11] == "157" &&  
  2953.           got[12] == "000" &&  
  2954.           got[13] == "124" &&  
  2955.           got[14] == "000" &&  
  2956.           got[15] == "000")
  2957.         {
  2958.           print "VAX G"
  2959.           found = 1
  2960.           exit
  2961.         }
  2962.       if (got[8]  == "300" &&  
  2963.           got[9]  == "033" &&  
  2964.           got[10] == "353" &&  
  2965.           got[11] == "171" &&  
  2966.           got[12] == "242" &&  
  2967.           got[13] == "240" &&  
  2968.           got[14] == "000" &&  
  2969.           got[15] == "000")
  2970.         {
  2971.           print "Cray CFP"
  2972.           found = 1
  2973.           exit
  2974.         }
  2975.     }
  2976. }
  2977. END {
  2978.   if (! found)
  2979.     print "unknown", saw
  2980. }
  2981. ]
  2982. EOF
  2983.   gmp_cv_c_double_format=`od -b conftest.$OBJEXT | $AWK -f conftest.awk`
  2984.   case $gmp_cv_c_double_format in
  2985.   unknown*)
  2986.     echo "cannot match anything, conftest.$OBJEXT contains" >&AC_FD_CC
  2987.     od -b conftest.$OBJEXT >&AC_FD_CC
  2988.     ;;
  2989.   esac
  2990. else
  2991.   AC_MSG_WARN([oops, cannot compile test program])
  2992. fi
  2993. rm -f conftest*
  2994. ])
  2995. AH_VERBATIM([HAVE_DOUBLE],
  2996. [/* Define one of the following to 1 for the format of a `double'.
  2997.    If your format is not among these choices, or you don't know what it is,
  2998.    then leave all undefined.
  2999.    IEEE_LITTLE_SWAPPED means little endian, but with the two 4-byte halves
  3000.    swapped, as used by ARM CPUs in little endian mode.  */
  3001. #undef HAVE_DOUBLE_IEEE_BIG_ENDIAN
  3002. #undef HAVE_DOUBLE_IEEE_LITTLE_ENDIAN
  3003. #undef HAVE_DOUBLE_IEEE_LITTLE_SWAPPED
  3004. #undef HAVE_DOUBLE_VAX_D
  3005. #undef HAVE_DOUBLE_VAX_G
  3006. #undef HAVE_DOUBLE_CRAY_CFP])
  3007. case $gmp_cv_c_double_format in
  3008.   "IEEE big endian")
  3009.     AC_DEFINE(HAVE_DOUBLE_IEEE_BIG_ENDIAN, 1)
  3010.     GMP_DEFINE_RAW("define_not_for_expansion(`HAVE_DOUBLE_IEEE_BIG_ENDIAN')", POST)
  3011.     ;;
  3012.   "IEEE little endian")
  3013.     AC_DEFINE(HAVE_DOUBLE_IEEE_LITTLE_ENDIAN, 1)
  3014.     GMP_DEFINE_RAW("define_not_for_expansion(`HAVE_DOUBLE_IEEE_LITTLE_ENDIAN')", POST)
  3015.     ;;
  3016.   "IEEE little endian, swapped halves")
  3017.     AC_DEFINE(HAVE_DOUBLE_IEEE_LITTLE_SWAPPED, 1) ;;
  3018.   "VAX D")
  3019.     AC_DEFINE(HAVE_DOUBLE_VAX_D, 1) ;;
  3020.   "VAX G")
  3021.     AC_DEFINE(HAVE_DOUBLE_VAX_G, 1) ;;
  3022.   "Cray CFP")
  3023.     AC_DEFINE(HAVE_DOUBLE_CRAY_CFP, 1) ;;
  3024.   "bad ARM software floats")
  3025.     ;;
  3026.   unknown*)
  3027.     AC_MSG_WARN([Could not determine float format.])
  3028.     AC_MSG_WARN([Conversions to and from "double" may be slow.])
  3029.     ;;
  3030.   *)
  3031.     AC_MSG_WARN([oops, unrecognised float format: $gmp_cv_c_double_format])
  3032.     ;;
  3033. esac
  3034. ])
  3035. dnl  GMP_C_STDARG
  3036. dnl  ------------
  3037. dnl  Test whether to use <stdarg.h> or <varargs.h>.
  3038. dnl
  3039. dnl  Notice the AC_DEFINE here is HAVE_STDARG to avoid clashing with
  3040. dnl  HAVE_STDARG_H which could arise from AC_CHECK_HEADERS.
  3041. dnl
  3042. dnl  This test might be slight overkill, after all there's really only going
  3043. dnl  to be ANSI or K&R and the two can be differentiated by AC_PROG_CC_STDC
  3044. dnl  or very likely by the setups for _PROTO in gmp.h.  On the other hand
  3045. dnl  this test is nice and direct, being what we're going to actually use.
  3046. AC_DEFUN([GMP_C_STDARG],
  3047. [AC_CACHE_CHECK([whether <stdarg.h> exists and works],
  3048.                 gmp_cv_c_stdarg,
  3049. [AC_TRY_COMPILE(
  3050. [#include <stdarg.h>
  3051. int foo (int x, ...)
  3052. {
  3053.   va_list  ap;
  3054.   int      y;
  3055.   va_start (ap, x);
  3056.   y = va_arg (ap, int);
  3057.   va_end (ap);
  3058.   return y;
  3059. }],,
  3060. gmp_cv_c_stdarg=yes, gmp_cv_c_stdarg=no)
  3061. ])
  3062. if test $gmp_cv_c_stdarg = yes; then
  3063.   AC_DEFINE(HAVE_STDARG, 1, [Define to 1 if <stdarg.h> exists and works])
  3064. fi
  3065. ])
  3066. dnl  GMP_FUNC_ALLOCA
  3067. dnl  ---------------
  3068. dnl  Determine whether "alloca" is available.  This is AC_FUNC_ALLOCA from
  3069. dnl  autoconf, but changed so it doesn't use alloca.c if alloca() isn't
  3070. dnl  available, and also to use gmp-impl.h for the conditionals detecting
  3071. dnl  compiler builtin alloca's.
  3072. AC_DEFUN([GMP_FUNC_ALLOCA],
  3073. [AC_REQUIRE([GMP_HEADER_ALLOCA])
  3074. AC_CACHE_CHECK([for alloca (via gmp-impl.h)],
  3075.                gmp_cv_func_alloca,
  3076. [AC_TRY_LINK(
  3077. GMP_INCLUDE_GMP_H
  3078. [#include "$srcdir/gmp-impl.h"
  3079. ],
  3080.   [char *p = (char *) alloca (1);],
  3081.   gmp_cv_func_alloca=yes,
  3082.   gmp_cv_func_alloca=no)])
  3083. if test $gmp_cv_func_alloca = yes; then
  3084.   AC_DEFINE(HAVE_ALLOCA, 1, [Define to 1 if alloca() works (via gmp-impl.h).])
  3085. fi
  3086. ])
  3087. AC_DEFUN([GMP_HEADER_ALLOCA],
  3088. [# The Ultrix 4.2 mips builtin alloca declared by alloca.h only works
  3089. # for constant arguments.  Useless!
  3090. AC_CACHE_CHECK([for working alloca.h],
  3091.                gmp_cv_header_alloca,
  3092. [AC_TRY_LINK([#include <alloca.h>],
  3093.   [char *p = (char *) alloca (2 * sizeof (int));],
  3094.   gmp_cv_header_alloca=yes,
  3095.   gmp_cv_header_alloca=no)])
  3096. if test $gmp_cv_header_alloca = yes; then
  3097.   AC_DEFINE(HAVE_ALLOCA_H, 1,
  3098.   [Define to 1 if you have <alloca.h> and it should be used (not on Ultrix).])
  3099. fi
  3100. ])
  3101. dnl  GMP_OPTION_ALLOCA
  3102. dnl  -----------------
  3103. dnl  Decide what to do about --enable-alloca from the user.
  3104. dnl  This is a macro so it can require GMP_FUNC_ALLOCA.
  3105. AC_DEFUN([GMP_OPTION_ALLOCA],
  3106. [AC_REQUIRE([GMP_FUNC_ALLOCA])
  3107. AC_CACHE_CHECK([how to allocate temporary memory],
  3108.                gmp_cv_option_alloca,
  3109. [case $enable_alloca in
  3110.   yes)
  3111.     gmp_cv_option_alloca=alloca
  3112.     ;;
  3113.   no)
  3114.     gmp_cv_option_alloca=malloc-reentrant
  3115.     ;;
  3116.   reentrant | notreentrant)
  3117.     case $gmp_cv_func_alloca in
  3118.     yes)  gmp_cv_option_alloca=alloca ;;
  3119.     *)    gmp_cv_option_alloca=malloc-$enable_alloca ;;
  3120.     esac
  3121.     ;;
  3122.   *)
  3123.     gmp_cv_option_alloca=$enable_alloca
  3124.     ;;
  3125. esac
  3126. ])
  3127. AH_VERBATIM([WANT_TMP],
  3128. [/* Define one of these to 1 for the desired temporary memory allocation
  3129.    method, per --enable-alloca. */
  3130. #undef WANT_TMP_ALLOCA
  3131. #undef WANT_TMP_REENTRANT
  3132. #undef WANT_TMP_NOTREENTRANT
  3133. #undef WANT_TMP_DEBUG])
  3134. case $gmp_cv_option_alloca in
  3135.   alloca)
  3136.     if test $gmp_cv_func_alloca = no; then
  3137.       AC_MSG_ERROR([--enable-alloca=alloca specified, but alloca not available])
  3138.     fi
  3139.     AC_DEFINE(WANT_TMP_ALLOCA)
  3140.     TAL_OBJECT=tal-reent$U.lo
  3141.     ;;
  3142.   malloc-reentrant)
  3143.     AC_DEFINE(WANT_TMP_REENTRANT)
  3144.     TAL_OBJECT=tal-reent$U.lo
  3145.     ;;
  3146.   malloc-notreentrant)
  3147.     AC_DEFINE(WANT_TMP_NOTREENTRANT)
  3148.     TAL_OBJECT=tal-notreent$U.lo
  3149.     ;;
  3150.   debug)
  3151.     AC_DEFINE(WANT_TMP_DEBUG)
  3152.     TAL_OBJECT=tal-debug$U.lo
  3153.     ;;
  3154.   *)
  3155.     # checks at the start of configure.in should protect us
  3156.     AC_MSG_ERROR([unrecognised --enable-alloca=$gmp_cv_option_alloca])
  3157.     ;;
  3158. esac
  3159. AC_SUBST(TAL_OBJECT)
  3160. ])
  3161. dnl  GMP_FUNC_SSCANF_WRITABLE_INPUT
  3162. dnl  ------------------------------
  3163. dnl  Determine whether sscanf requires a writable input string.
  3164. dnl
  3165. dnl  It might be nicer to run a program to determine this when doing a
  3166. dnl  native build, but the systems afflicted are few and far between these
  3167. dnl  days, so it seems good enough just to list them.
  3168. AC_DEFUN([GMP_FUNC_SSCANF_WRITABLE_INPUT],
  3169. [AC_CACHE_CHECK([whether sscanf needs writable input],
  3170.                  gmp_cv_func_sscanf_writable_input,
  3171. [case $host in
  3172.   *-*-hpux9 | *-*-hpux9.*)
  3173.      gmp_cv_func_sscanf_writable_input=yes ;;
  3174.   *) gmp_cv_func_sscanf_writable_input=no  ;;
  3175. esac
  3176. ])
  3177. case $gmp_cv_func_sscanf_writable_input in
  3178.   yes) AC_DEFINE(SSCANF_WRITABLE_INPUT, 1,
  3179.                  [Define to 1 if sscanf requires writable inputs]) ;;
  3180.   no)  ;;
  3181.   *)   AC_MSG_ERROR([unrecognised $gmp_cv_func_sscanf_writable_input]) ;;
  3182. esac
  3183. ])
  3184. dnl  GMP_FUNC_VSNPRINTF
  3185. dnl  ------------------
  3186. dnl  Check whether vsnprintf exists, and works properly.
  3187. dnl
  3188. dnl  Systems without vsnprintf include mingw32, OSF 4.
  3189. dnl
  3190. dnl  Sparc Solaris 2.7 in 64-bit mode doesn't always truncate, making
  3191. dnl  vsnprintf like vsprintf, and hence completely useless.  On one system a
  3192. dnl  literal string is enough to provoke the problem, on another a "%n" was
  3193. dnl  needed.  There seems to be something weird going on with the optimizer
  3194. dnl  or something, since on the first system adding a second check with
  3195. dnl  "%n", or even just an initialized local variable, makes it work.  In
  3196. dnl  any case, without bothering to get to the bottom of this, the two
  3197. dnl  program runs in the code below end up successfully detecting the
  3198. dnl  problem.
  3199. dnl
  3200. dnl  glibc 2.0.x returns either -1 or bufsize-1 for an overflow (both seen,
  3201. dnl  not sure which 2.0.x does which), but still puts the correct null
  3202. dnl  terminated result into the buffer.
  3203. AC_DEFUN([GMP_FUNC_VSNPRINTF],
  3204. [AC_REQUIRE([GMP_C_STDARG])
  3205. AC_CHECK_FUNC(vsnprintf,
  3206.               [gmp_vsnprintf_exists=yes],
  3207.               [gmp_vsnprintf_exists=no])
  3208. if test "$gmp_vsnprintf_exists" = no; then
  3209.   gmp_cv_func_vsnprintf=no
  3210. else
  3211.   AC_CACHE_CHECK([whether vsnprintf works],
  3212.                  gmp_cv_func_vsnprintf,
  3213.   [gmp_cv_func_vsnprintf=yes
  3214.    for i in 'check ("hello world");' 'int n; check ("%nhello world", &n);'; do
  3215.      AC_TRY_RUN([
  3216. #include <string.h>  /* for strcmp */
  3217. #include <stdio.h>   /* for vsnprintf */
  3218. #if HAVE_STDARG
  3219. #include <stdarg.h>
  3220. #else
  3221. #include <varargs.h>
  3222. #endif
  3223. int
  3224. #if HAVE_STDARG
  3225. check (const char *fmt, ...)
  3226. #else
  3227. check (va_alist)
  3228.      va_dcl
  3229. #endif
  3230. {
  3231.   static char  buf[128];
  3232.   va_list  ap;
  3233.   int      ret;
  3234. #if HAVE_STDARG
  3235.   va_start (ap, fmt);
  3236. #else
  3237.   char *fmt;
  3238.   va_start (ap);
  3239.   fmt = va_arg (ap, char *);
  3240. #endif
  3241.   ret = vsnprintf (buf, 4, fmt, ap);
  3242.   if (strcmp (buf, "hel") != 0)
  3243.     exit (1);
  3244.   /* allowed return values */
  3245.   if (ret != -1 && ret != 3 && ret != 11)
  3246.     exit (2);
  3247.   return 0;
  3248. }
  3249. int
  3250. main ()
  3251. {
  3252. $i
  3253.   exit (0);
  3254. }
  3255. ],
  3256.       [:],
  3257.       [gmp_cv_func_vsnprintf=no; break],
  3258.       [gmp_cv_func_vsnprintf=probably; break])
  3259.   done
  3260.   ])
  3261.   if test "$gmp_cv_func_vsnprintf" = probably; then
  3262.     AC_MSG_WARN([cannot check for properly working vsnprintf when cross compiling, will assume it's ok])
  3263.   fi
  3264.   if test "$gmp_cv_func_vsnprintf" != no; then
  3265.     AC_DEFINE(HAVE_VSNPRINTF,1,
  3266.     [Define to 1 if you have the `vsnprintf' function and it works properly.])
  3267.   fi
  3268. fi
  3269. ])
  3270. dnl  GMP_H_ANSI
  3271. dnl  ----------
  3272. dnl  Check whether gmp.h recognises the compiler as ANSI capable.
  3273. AC_DEFUN([GMP_H_ANSI],
  3274. [AC_REQUIRE([AC_PROG_CC_STDC])
  3275. case $ac_cv_prog_cc_stdc in
  3276.   no)
  3277.     ;;
  3278.   *)
  3279.     AC_TRY_COMPILE(
  3280. GMP_INCLUDE_GMP_H
  3281. [#if ! __GMP_HAVE_PROTOTYPES
  3282. die die die
  3283. #endif
  3284. ],,,
  3285.     [AC_MSG_WARN([gmp.h doesnt recognise compiler as ANSI, prototypes and "const" will be unavailable])])
  3286.     ;;
  3287. esac
  3288. ])
  3289. dnl  GMP_H_EXTERN_INLINE
  3290. dnl  -------------------
  3291. dnl  If the compiler has an "inline" of some sort, check whether the
  3292. dnl  #ifdef's in gmp.h recognise it.
  3293. AC_DEFUN([GMP_H_EXTERN_INLINE],
  3294. [AC_REQUIRE([AC_C_INLINE])
  3295. case $ac_cv_c_inline in
  3296. no) ;;
  3297. *)
  3298.   AC_TRY_COMPILE(
  3299. [#define __GMP_WITHIN_CONFIGURE_INLINE 1
  3300. ]GMP_INCLUDE_GMP_H[
  3301. #ifndef __GMP_EXTERN_INLINE
  3302. die die die
  3303. #endif
  3304. ],,,
  3305.   [case $ac_cv_c_inline in
  3306.   yes) tmp_inline=inline ;;
  3307.   *)   tmp_inline=$ac_cv_c_inline ;;
  3308.   esac
  3309.   AC_MSG_WARN([gmp.h doesnt recognise compiler "$tmp_inline", inlines will be unavailable])])
  3310.   ;;
  3311. esac
  3312. ])
  3313. dnl  GMP_H_HAVE_FILE
  3314. dnl  ---------------
  3315. dnl  Check whether the #ifdef's in gmp.h recognise when stdio.h has been
  3316. dnl  included to get FILE.
  3317. AC_DEFUN([GMP_H_HAVE_FILE],
  3318. [AC_TRY_COMPILE(
  3319. [#include <stdio.h>]
  3320. GMP_INCLUDE_GMP_H
  3321. [#if ! _GMP_H_HAVE_FILE
  3322. die die die
  3323. #endif
  3324. ],,,
  3325.   [AC_MSG_WARN([gmp.h doesnt recognise <stdio.h>, FILE prototypes will be unavailable])])
  3326. ])
  3327. dnl  GMP_PROG_CC_FOR_BUILD
  3328. dnl  ---------------------
  3329. dnl  Establish CC_FOR_BUILD, a C compiler for the build system.
  3330. dnl
  3331. dnl  If CC_FOR_BUILD is set then it's expected to work, likewise the old
  3332. dnl  style HOST_CC, otherwise some likely candidates are tried, the same as
  3333. dnl  configfsf.guess.
  3334. AC_DEFUN([GMP_PROG_CC_FOR_BUILD],
  3335. [AC_REQUIRE([AC_PROG_CC])
  3336. if test -n "$CC_FOR_BUILD"; then
  3337.   GMP_PROG_CC_FOR_BUILD_WORKS($CC_FOR_BUILD,,
  3338.     [AC_MSG_ERROR([Specified CC_FOR_BUILD doesn't seem to work])])
  3339. elif test -n "$HOST_CC"; then
  3340.   GMP_PROG_CC_FOR_BUILD_WORKS($HOST_CC,
  3341.     [CC_FOR_BUILD=$HOST_CC],
  3342.     [AC_MSG_ERROR([Specified HOST_CC doesn't seem to work])])
  3343. else
  3344.   for i in "$CC" "$CC $CFLAGS $CPPFLAGS" cc gcc c89 c99; do
  3345.     GMP_PROG_CC_FOR_BUILD_WORKS($i,
  3346.       [CC_FOR_BUILD=$i
  3347.        break])
  3348.   done
  3349.   if test -z "$CC_FOR_BUILD"; then
  3350.     AC_MSG_ERROR([Cannot find a build system compiler])
  3351.   fi
  3352. fi
  3353. AC_ARG_VAR(CC_FOR_BUILD,[build system C compiler])
  3354. AC_SUBST(CC_FOR_BUILD)
  3355. ])
  3356. dnl  GMP_PROG_CC_FOR_BUILD_WORKS(cc/cflags[,[action-if-good][,action-if-bad]])
  3357. dnl  -------------------------------------------------------------------------
  3358. dnl  See if the given cc/cflags works on the build system.
  3359. dnl
  3360. dnl  It seems easiest to just use the default compiler output, rather than
  3361. dnl  figuring out the .exe or whatever at this stage.
  3362. AC_DEFUN([GMP_PROG_CC_FOR_BUILD_WORKS],
  3363. [AC_MSG_CHECKING([build system compiler $1])
  3364. # remove anything that might look like compiler output to our "||" expression
  3365. rm -f conftest* a.out b.out a.exe a_out.exe
  3366. cat >conftest.c <<EOF
  3367. int
  3368. main ()
  3369. {
  3370.   exit(0);
  3371. }
  3372. EOF
  3373. gmp_compile="$1 conftest.c"
  3374. cc_for_build_works=no
  3375. if AC_TRY_EVAL(gmp_compile); then
  3376.   if (./a.out || ./b.out || ./a.exe || ./a_out.exe || ./conftest) >&AC_FD_CC 2>&1; then
  3377.     cc_for_build_works=yes
  3378.   fi
  3379. fi
  3380. rm -f conftest* a.out b.out a.exe a_out.exe
  3381. AC_MSG_RESULT($cc_for_build_works)
  3382. if test "$cc_for_build_works" = yes; then
  3383.   ifelse([$2],,:,[$2])
  3384. else
  3385.   ifelse([$3],,:,[$3])
  3386. fi
  3387. ])
  3388. dnl  GMP_PROG_CPP_FOR_BUILD
  3389. dnl  ---------------------
  3390. dnl  Establish CPP_FOR_BUILD, the build system C preprocessor.
  3391. dnl  The choices tried here are the same as AC_PROG_CPP, but with
  3392. dnl  CC_FOR_BUILD.
  3393. AC_DEFUN([GMP_PROG_CPP_FOR_BUILD],
  3394. [AC_REQUIRE([GMP_PROG_CC_FOR_BUILD])
  3395. AC_MSG_CHECKING([for build system preprocessor])
  3396. if test -z "$CPP_FOR_BUILD"; then
  3397.   AC_CACHE_VAL(gmp_cv_prog_cpp_for_build,
  3398.   [cat >conftest.c <<EOF
  3399. #define FOO BAR
  3400. EOF
  3401.   for i in "$CC_FOR_BUILD -E" "$CC_FOR_BUILD -E -traditional-cpp" "/lib/cpp"; do
  3402.     gmp_compile="$i conftest.c"
  3403.     if AC_TRY_EVAL(gmp_compile) >&AC_FD_CC 2>&1; then
  3404.       gmp_cv_prog_cpp_for_build=$i
  3405.       break
  3406.     fi
  3407.   done
  3408.   rm -f conftest* a.out b.out a.exe a_out.exe
  3409.   if test -z "$gmp_cv_prog_cpp_for_build"; then
  3410.     AC_MSG_ERROR([Cannot find build system C preprocessor.])
  3411.   fi
  3412.   ])
  3413.   CPP_FOR_BUILD=$gmp_cv_prog_cpp_for_build
  3414. fi
  3415. AC_MSG_RESULT([$CPP_FOR_BUILD])
  3416. AC_ARG_VAR(CPP_FOR_BUILD,[build system C preprocessor])
  3417. AC_SUBST(CPP_FOR_BUILD)
  3418. ])
  3419. dnl  GMP_PROG_EXEEXT_FOR_BUILD
  3420. dnl  -------------------------
  3421. dnl  Determine EXEEXT_FOR_BUILD, the build system executable suffix.
  3422. dnl
  3423. dnl  The idea is to find what "-o conftest$foo" will make it possible to run
  3424. dnl  the program with ./conftest.  On Unix-like systems this is of course
  3425. dnl  nothing, for DOS it's ".exe", or for a strange RISC OS foreign file
  3426. dnl  system cross compile it can be ",ff8" apparently.  Not sure if the
  3427. dnl  latter actually applies to a build-system executable, maybe it doesn't,
  3428. dnl  but it won't hurt to try.
  3429. AC_DEFUN([GMP_PROG_EXEEXT_FOR_BUILD],
  3430. [AC_REQUIRE([GMP_PROG_CC_FOR_BUILD])
  3431. AC_CACHE_CHECK([for build system executable suffix],
  3432.                gmp_cv_prog_exeext_for_build,
  3433. [cat >conftest.c <<EOF
  3434. int
  3435. main ()
  3436. {
  3437.   exit (0);
  3438. }
  3439. EOF
  3440. for i in .exe ,ff8 ""; do
  3441.   gmp_compile="$CC_FOR_BUILD conftest.c -o conftest$i"
  3442.   if AC_TRY_EVAL(gmp_compile); then
  3443.     if (./conftest) 2>&AC_FD_CC; then
  3444.       gmp_cv_prog_exeext_for_build=$i
  3445.       break
  3446.     fi
  3447.   fi
  3448. done
  3449. rm -f conftest*
  3450. if test "${gmp_cv_prog_exeext_for_build+set}" != set; then
  3451.   AC_MSG_ERROR([Cannot determine executable suffix])
  3452. fi
  3453. ])
  3454. AC_SUBST(EXEEXT_FOR_BUILD,$gmp_cv_prog_exeext_for_build)
  3455. ])
  3456. dnl  GMP_C_FOR_BUILD_ANSI
  3457. dnl  --------------------
  3458. dnl  Determine whether CC_FOR_BUILD is ANSI, and establish U_FOR_BUILD
  3459. dnl  accordingly.
  3460. dnl
  3461. dnl  FIXME: Use AC_PROG_CC sets ac_cv_prog_cc_c89 which could be used instead
  3462. AC_DEFUN([GMP_C_FOR_BUILD_ANSI],
  3463. [AC_REQUIRE([GMP_PROG_CC_FOR_BUILD])
  3464. AC_CACHE_CHECK([whether build system compiler is ANSI],
  3465.                gmp_cv_c_for_build_ansi,
  3466. [cat >conftest.c <<EOF
  3467. int
  3468. main (int argc, char **argv)
  3469. {
  3470.   exit(0);
  3471. }
  3472. EOF
  3473. gmp_compile="$CC_FOR_BUILD conftest.c"
  3474. if AC_TRY_EVAL(gmp_compile); then
  3475.   gmp_cv_c_for_build_ansi=yes
  3476. else
  3477.   gmp_cv_c_for_build_ansi=no
  3478. fi
  3479. rm -f conftest* a.out b.out a.exe a_out.exe
  3480. ])
  3481. if test "$gmp_cv_c_for_build_ansi" = yes; then
  3482.   U_FOR_BUILD=
  3483. else
  3484.   AC_SUBST(U_FOR_BUILD,_)
  3485. fi
  3486. ])
  3487. dnl  GMP_CHECK_LIBM_FOR_BUILD
  3488. dnl  ------------------------
  3489. dnl  Establish LIBM_FOR_BUILD as -lm, if that seems to work.
  3490. dnl
  3491. dnl  Libtool AC_CHECK_LIBM also uses -lmw on *-ncr-sysv4.3*, if it works.
  3492. dnl  Don't know what that does, lets assume it's not needed just for log().
  3493. AC_DEFUN([GMP_CHECK_LIBM_FOR_BUILD],
  3494. [AC_REQUIRE([GMP_PROG_CC_FOR_BUILD])
  3495. AC_CACHE_CHECK([for build system compiler math library],
  3496.                gmp_cv_check_libm_for_build,
  3497. [cat >conftest.c <<EOF
  3498. int
  3499. main ()
  3500. {
  3501.   exit(0);
  3502. }
  3503. double d;
  3504. double
  3505. foo ()
  3506. {
  3507.   return log (d);
  3508. }
  3509. EOF
  3510. gmp_compile="$CC_FOR_BUILD conftest.c -lm"
  3511. if AC_TRY_EVAL(gmp_compile); then
  3512.   gmp_cv_check_libm_for_build=-lm
  3513. else
  3514.   gmp_cv_check_libm_for_build=no
  3515. fi
  3516. rm -f conftest* a.out b.out a.exe a_out.exe
  3517. ])
  3518. case $gmp_cv_check_libm_for_build in
  3519.   yes) AC_SUBST(LIBM_FOR_BUILD,-lm) ;;
  3520.   no)  LIBM_FOR_BUILD= ;;
  3521.   *)   LIBM_FOR_BUILD=$gmp_cv_check_libm_for_build ;;
  3522. esac
  3523. ])