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