git.chise.org Git - chise/xemacs-chise.git-/blob - aclocal.m4

   1 dnl aclocal.m4 --- Dynamically linked library support for XEmacs
   2 dnl Copyright (C) 1998, 1999 J. Kean Johnston.
   3 dnl Author: J. Kean Johnston <jkj@sco.com>, based on work in libtool.
   4 dnl This file is part of XEmacs.
   5
   6 dnl
   7 dnl There are several things we care about here. First, we need to find
   8 dnl out how we create an executable that has its symbols exported, so
   9 dnl that dynamically loaded modules have access to the internal XEmacs
  10 dnl symbols. This is stored in ``ld_dynamic_link_flags'' and is used
  11 dnl in the main Makefile.
  12 dnl Next, we need to know how we compile actual shared libraries, and
  13 dnl the objects in them.  For these purposes, we need to determine the
  14 dnl C compiler flags used to produce shared objects (``dll_cflags''),
  15 dnl what linker to use to create the final shared object that will be
  16 dnl loaded (``dll_ld'') and the flags to pass to that linker
  17 dnl (``dll_ldflags''). This information is used by ellcc to build up
  18 dnl the command line when compiling modules. We build up two other commands
  19 dnl for extremely weird systems where special things need to be done.
  20 dnl The first is ``dll_ldo'', which is the flag used to specify the output
  21 dnl file name, and the second is ``dll_post'' which is inserted after the
  22 dnl list of objects.
  23 dnl After all of this, we should be able to:
  24 dnl    $(CC) $(CFLAGS) $(dll_cflags) -c module.c
  25 dnl to produce a single shared object
  26 dnl And then:
  27 dnl   $(dll_ld) $(dll_ldflags) $(dll_ldo) module.ell module.o $(dll_post)
  28 dnl to create the loadable shared library.
  29 dnl
  30 dnl NOTE: In the code below, where I have modified things to work with
  31 dnl XEmacs, we use $canonical instead of libtool's $host, and we use
  32 dnl $internal_configuration instead of $host_alias. To make typing
  33 dnl shorter we assign these to $xehost and $xealias
  34
  35 AC_DEFUN(XE_SHLIB_STUFF,[
  36 dll_ld=
  37 dll_ldflags=
  38 dll_cflags=
  39 dll_post=
  40 dll_ldo="-o"
  41 ld_dynamic_link_flags=
  42 xehost=$canonical
  43 xealias=$internal_configuration
  44
  45 AC_CHECKING([how to build dynamic libraries for ${xehost}])
  46 # Transform *-*-linux* to *-*-linux-gnu*, to support old configure scripts.
  47 case "$xehost" in
  48 *-*-linux-gnu*) ;;
  49 *-*-linux*) xehost=`echo $xehost | sed 's/^\(.*-.*-linux\)\(.*\)$/\1-gnu\2/'`
  50 esac
  51
  52 changequote(<<, >>)dnl
  53 xehost_cpu=`echo $xehost | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
  54 xehost_vendor=`echo $xehost | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
  55 xehost_os=`echo $xehost | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
  56 changequote([, ])dnl
  57
  58 case "$xehost_os" in
  59 aix3*)
  60   # AIX sometimes has problems with the GCC collect2 program.  For some
  61   # reason, if we set the COLLECT_NAMES environment variable, the problems
  62   # vanish in a puff of smoke.
  63   if test "${COLLECT_NAMES+set}" != set; then
  64     COLLECT_NAMES=
  65     export COLLECT_NAMES
  66   fi
  67   ;;
  68 esac
  69
  70 # Now see if the compiler is really GCC.
  71 if test "$GCC" = "yes"; then
  72   XEGCC=yes
  73 else
  74   AC_MSG_CHECKING(checking whether we are using GNU C)
  75   AC_EGREP_CPP(yes,[
  76 #ifdef __GNUC__
  77   yes;
  78 #endif
  79 ],XEGCC=yes, XEGCC=no)
  80   AC_MSG_RESULT([${XEGCC}])
  81 fi
  82
  83 AC_MSG_CHECKING(how to produce PIC code)
  84 wl=
  85
  86 can_build_shared=yes
  87 if test "$XEGCC" = yes; then
  88   wl='-Wl,'
  89
  90   case "$xehost_os" in
  91   aix3* | aix4* | irix5* | irix6* | osf3* | osf4*)
  92     # PIC is the default for these OSes.
  93     ;;
  94
  95   aix3* | aix4* | os2*)
  96     # We can build DLLs from non-PIC.
  97     ;;
  98   amigaos*)
  99     # FIXME: we need at least 68020 code to build shared libraries, but
 100     # adding the `-m68020' flag to GCC prevents building anything better,
 101     # like `-m68040'.
 102     dll_cflags='-m68020 -resident32 -malways-restore-a4'
 103     ;;
 104   *cygwin* | *mingw* )
 105     # PIC is the default
 106     ;;
 107   *)
 108     dll_cflags='-fPIC'
 109     ;;
 110   esac
 111 else
 112   # PORTME Check for PIC flags for the system compiler.
 113   case "$xehost_os" in
 114   hpux9* | hpux1[[0-9]]*)
 115     # Is there a better link_static_flag that works with the bundled CC?
 116     wl='-Wl,'
 117     dll_cflags='+Z'
 118     ;;
 119
 120   irix5* | irix6*)
 121     wl='-Wl,'
 122     # PIC (with -KPIC) is the default.
 123     ;;
 124
 125   os2*)
 126     # We can build DLLs from non-PIC.
 127     ;;
 128
 129   osf3* | osf4*)
 130     # All OSF/1 code is PIC.
 131     wl='-Wl,'
 132     ;;
 133
 134   sco3.2v5*)
 135     dll_cflags='-belf -Kpic'
 136     wl='-Wl,'
 137     ;;
 138
 139   unixware*)
 140     dll_cflags="-KPIC"
 141     wl="-Wl,"
 142     ;;
 143
 144   sysv4*)
 145     dll_cflags="-KPIC"
 146     wl="-Wl,"
 147     ;;
 148
 149   sysv5*)
 150     dll_cflags="-KPIC"
 151     wl="-Wl,"
 152     ;;
 153
 154   solaris2*)
 155     dll_cflags='-KPIC'
 156     wl='-Wl,'
 157     ;;
 158
 159   sunos4*)
 160     dll_cflags='-PIC'
 161     wl='-Qoption ld '
 162     ;;
 163
 164   uts4*)
 165     dll_cflags='-pic'
 166     ;;
 167
 168   *)
 169     can_build_shared=no
 170     ;;
 171   esac
 172 fi
 173
 174 if test -n "$dll_cflags"; then
 175   AC_MSG_RESULT([${dll_cflags}])
 176
 177   # Check to make sure the dll_cflags actually works.
 178   AC_MSG_CHECKING([if PIC flag ${dll_cflags} really works])
 179   save_CFLAGS="$CFLAGS"
 180   CFLAGS="$CFLAGS $dll_cflags -DPIC"
 181   AC_TRY_COMPILE(,[int x=0;],[
 182     # On HP-UX, the stripped-down bundled CC doesn't accept +Z, but also
 183     # reports no error.  So, we need to grep stderr for (Bundled).
 184     if grep '(Bundled)' config.log >/dev/null; then
 185       AC_MSG_RESULT(no)
 186       can_build_shared=no
 187       dll_cflags=
 188     else
 189       AC_MSG_RESULT(yes)
 190     fi], [AC_MSG_RESULT(no)
 191     can_build_shared=no
 192     dll_cflags=])
 193   CFLAGS="$save_CFLAGS"
 194 else
 195   AC_MSG_RESULT(none)
 196 fi
 197
 198 dnl
 199 dnl Now comes the LD trickery. We do things differently to libtool here.
 200 dnl I believe that libtool is incorrect in trying to drive the linker
 201 dnl directly. This can cause considerable problems if the module you are
 202 dnl compiling has C++ or other static initializers. If we use ld directly,
 203 dnl we don't end up with the crt stuff being linked in, and we don't end up
 204 dnl with any .init or .fini sections (or the moral equivalent thereof).
 205 dnl gcc takes great care to do this properly when invoked in -shared
 206 dnl mode, and we really do want this behavior. Perhaps the libtool folks
 207 dnl are not aware that any SVR4 based dynamic loader will automatically
 208 dnl execute code in the .init section before dlopen() returns. This is
 209 dnl vital, as the module may have been compiled to rely on that behavior.
 210 dnl
 211 dnl So, having said all of that, we diverge from libtool significantly
 212 dnl here. We want to try and use the C compiler as much as possible. Only
 213 dnl if the C compiler itself cannot create shared libraries to we try to
 214 dnl find the linker.
 215 dnl
 216 dnl The other advantage to my scheme is that it removes the dependancy
 217 dnl on a given compiler version remaining static with relation to the
 218 dnl version of XEmacs. With the libtool way, it picks up the linker that
 219 dnl gcc uses, which can be the internal collect2 that comes with gcc.
 220 dnl If the user ever changes their compiler version, the paths will no
 221 dnl longer be correct, and ellcc will break. This is clearly unacceptable.
 222 dnl By using the compiler driver on the path, we don't have this problem.
 223 dnl If that is not clear, consider that gcc -print-prog-name=ld can
 224 dnl produce something along the lines of:
 225 dnl   /usr/local/lib/gcc-lib/OS-NAME/GCC-VERSION/ld
 226 dnl If you ever change GCC versions, then that path no longer exists.
 227 dnl
 228 dnl So, we change the check order here. We first check to see if we are
 229 dnl using GCC, and if so, we see if -shared works. If it does, great.
 230 dnl If we are not using gcc, but the system C compiler can produce
 231 dnl shared objects, we try that. Only if all of that fails do we revert
 232 dnl back to the libtool ld trickery.
 233 dnl
 234 dnl We don't do ANY of this if we can't produce shared objects.
 235 dnl
 236 if test "$can_build_shared" = "yes"; then
 237 cc_produces_so=no
 238 xldf=
 239 xcldf=
 240 AC_MSG_CHECKING(if C compiler can produce shared libraries)
 241 if test "$XEGCC" = yes; then
 242   xcldf="-shared"
 243   xldf="-shared"
 244 else # Not using GCC
 245   case "$xehost_os" in
 246     aix3* | aix4*)
 247       xldf="-bE:ELLSONAME.exp -H512 -T512 -bhalt:4 -bM:SRE -bnoentry -lc"
 248       xcldf="${wl}-bE:ELLSONAME.exp ${wl}-H512 ${wl}-T512 ${wl}-bhalt:4 ${wl}-bM:SRE ${wl}-bnoentry ${wl}-lc"
 249       ;;
 250
 251     freebsd2* | netbsd* | openbsd*)
 252       xldf="-Bshareable"
 253       xcldf="${wl}-Bshareable"
 254       ;;
 255
 256     freebsd3*)
 257       xcldf="-shared"
 258       ;;
 259
 260     hpux*)
 261       xldf="-b +s"
 262       xcldf="${wl}-b ${wl}+s"
 263       ;;
 264
 265     irix5* | irix6* | osf3* | osf4*)
 266       xcldf="${wl}-shared"
 267       xldf="-shared"
 268       ;;
 269
 270     sco3.2v5* | unixware* | sysv5* | sysv4* | solaris2* | solaris7* | uts4*)
 271       xcldf="-G"
 272       xldf="-G"
 273       ;;
 274
 275     sunos4*)
 276       xcldf="${wl}-assert ${wl}pure-text ${wl}-Bstatic"
 277       xldf="-assert pure-text -Bstatic"
 278       ;;
 279   esac
 280 fi # End if if we are using gcc
 281
 282 if test -n "$xcldf"; then
 283   save_LDFLAGS=$LDFLAGS
 284   save_LIBS=$LIBS
 285   save_xe_libs=$xe_libs
 286   LDFLAGS="$xcldf $LDFLAGS"
 287   LIBS=
 288   xe_libs=
 289   ac_link='${CC-cc} -o conftest $CFLAGS '"$xe_cppflags $xe_ldflags"' conftest.$ac_ext '"$xe_libs"' 1>&AC_FD_CC'
 290   AC_TRY_LINK(,[int x=0;],cc_produces_so=yes,cc_produces_so=no)
 291   LDFLAGS=$save_LDFLAGS
 292   LIBS=$save_LIBS
 293   xe_libs=$save_xe_libs
 294   ac_link='${CC-cc} -o conftest $CFLAGS '"$xe_cppflags $xe_ldflags"' conftest.$ac_ext '"$xe_libs"' 1>&AC_FD_CC'
 295 else
 296   cc_produces_so=no
 297 fi
 298 AC_MSG_RESULT([${cc_produces_so}])
 299
 300 LTLD=$LD
 301 if test -z "$LTLD"; then
 302   ac_prog=ld
 303   if test "$XEGCC" = yes; then
 304     # Check if gcc -print-prog-name=ld gives a path.
 305     AC_MSG_CHECKING(for ld used by GCC)
 306     ac_prog=`($CC -print-prog-name=ld) 2>&5`
 307     case "$ac_prog" in
 308     # Accept absolute paths.
 309     /*)
 310       if test -z "$LTLD"; then
 311         case "$ac_prog" in
 312           *gcc-lib*) LTLD="$CC"
 313                      ;;
 314           *)         LTLD="$ac_prog"
 315                      ;;
 316         esac
 317       fi
 318       ;;
 319     "")
 320       # If it fails, then pretend we aren't using GCC.
 321       ac_prog=ld
 322       ;;
 323     *)
 324       # If it is relative, then search for the first ld in PATH.
 325       with_gnu_ld=unknown
 326       ;;
 327     esac
 328   else
 329     AC_MSG_CHECKING(for GNU ld)
 330   fi
 331
 332   if test -z "$LTLD"; then
 333     IFS="${IFS=         }"; ac_save_ifs="$IFS"; IFS="${IFS}:"
 334     for ac_dir in $PATH; do
 335       test -z "$ac_dir" && ac_dir=.
 336       if test -f "$ac_dir/$ac_prog"; then
 337         LTLD="$ac_dir/$ac_prog"
 338         # Check to see if the program is GNU ld.  I'd rather use --version,
 339         # but apparently some GNU ld's only accept -v.
 340         # Break only if it was the GNU/non-GNU ld that we prefer.
 341         if "$LTLD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then
 342           xe_gnu_ld=yes
 343         else
 344           xe_gnu_ld=no
 345         fi
 346       fi
 347     done
 348     IFS="$ac_save_ifs"
 349   fi
 350
 351   if test -n "$LTLD"; then
 352     AC_MSG_RESULT([${LTLD}])
 353   else
 354     AC_MSG_RESULT(no)
 355   fi
 356
 357   if test -z "$LTLD" -a "$cc_produces_so" = no; then
 358     AC_MSG_ERROR(no acceptable linker found in \$PATH)
 359     exit 1
 360   fi
 361 fi
 362
 363 dnl
 364 dnl Order of the tests changed somewhat to prevent repetition
 365 dnl
 366 ld_dynamic_link_flags=
 367
 368 # Check to see if it really is or isn't GNU ld.
 369 AC_MSG_CHECKING(if the linker is GNU ld)
 370 # I'd rather use --version here, but apparently some GNU ld's only accept -v.
 371 if $LTLD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then
 372   xe_gnu_ld=yes
 373 else
 374   xe_gnu_ld=no
 375 fi
 376 AC_MSG_RESULT([${xe_gnu_ld}])
 377
 378 case "$xehost_os" in
 379   amigaos* | sunos4*)
 380     # On these operating systems, we should treat GNU ld like the system ld.
 381     gnu_ld_acts_native=yes
 382     ;;
 383   *)
 384     gnu_ld_acts_native=no
 385     ;;
 386 esac
 387
 388 if test "$cc_produces_so" = "yes"; then
 389   dll_ld=$CC
 390   dll_ldflags=$xcldf
 391   can_build_shared=yes
 392   ld_shlibs=yes
 393 else
 394   # OK - only NOW do we futz about with ld.
 395   # See if the linker supports building shared libraries.
 396   AC_MSG_CHECKING(whether the linker supports shared libraries)
 397   dll_ld=$CC
 398   dll_ldflags=$LDFLAGS
 399   ld_shlibs=yes
 400   can_build_shared=yes
 401   if test "$xe_gnu_ld" = yes && test "$gnu_ld_acts_native" != yes; then
 402     # See if GNU ld supports shared libraries.
 403     if $LTLD --help 2>&1 | egrep ': supported targets:.* elf' > /dev/null; then
 404       dll_ld=$CC
 405       dll_ldflags="-shared"
 406       ld_shlibs=yes
 407     else
 408       ld_shlibs=no
 409     fi
 410   else
 411     # PORTME fill in a description of your system's linker (not GNU ld)
 412     case "$xehost_os" in
 413     aix3*)
 414       dll_ld=$LTLD
 415       dll_ldflags=$xldf
 416       ;;
 417
 418     aix4*)
 419       dll_ldflags=$xcldf
 420       ;;
 421
 422     # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor
 423     # support.  Future versions do this automatically, but an explicit c++rt0.o
 424     # doesn't break anything, and helps significantly (at the cost of a little
 425     # extra space).
 426     freebsd2.2*)
 427       dll_ld=$LTLD
 428       dll_ldflags=$xldf
 429       dll_post="/usr/lib/c++rt0.o"
 430       ;;
 431
 432     # Unfortunately, older versions of FreeBSD 2 don't have this feature.
 433     freebsd2*)
 434       dll_ld=$LTLD
 435       dll_ldflags="-Bshareable"
 436       ;;
 437
 438     # FreeBSD 3, at last, uses gcc -shared to do shared libraries.
 439     freebsd3*)
 440       dll_ldflags="-shared"
 441       ;;
 442
 443     hpux*)
 444       dll_ld=$LTLD
 445       dll_ldflags=$xldf
 446       ;;
 447
 448     irix5* | irix6*)
 449       dll_ld=$LTLD
 450       dll_ldflags=$xldf
 451       ;;
 452
 453     netbsd*)
 454       # Tested with NetBSD 1.2 ld
 455       dll_ld=$LTLD
 456       dll_ldflags=$xldf
 457       ;;
 458
 459     openbsd*)
 460       dll_ld=$LTLD
 461       dll_ldflags=$xldf
 462       ;;
 463
 464     osf3* | osf4*)
 465       dll_ld=$LTLD
 466       dll_ldflags=$xldf
 467       ;;
 468
 469     # For both SCO and Solaris we MAY want to have LDFLAGS include -z text
 470     sco3.2v5* | unixware* | sysv5* | sysv4* | solaris2* | solaris7*)
 471       dll_ld=$LTLD
 472       case "$dll_ld" in
 473         *gcc*) dll_ldflags="-shared"
 474                dll_ld=$CC
 475                ;;
 476         *)     dll_ldflags="-G"
 477                ;;
 478       esac
 479       ;;
 480
 481     sunos4*)
 482       if test "$XEGCC" = yes; then
 483         dll_ld=$CC
 484       else
 485         dll_ld=$LTLD
 486       fi
 487       dll_ldflags=$xldf
 488       ;;
 489
 490     uts4*)
 491       dll_ld=$LTLD
 492       dll_ldflags="-G"
 493       ;;
 494
 495     bsdi*)
 496       dll_ldflags="-r"
 497       dll_ld="shlicc2"
 498       ;;
 499
 500     *)
 501       ld_shlibs=no
 502       can_build_shared=no
 503       ;;
 504     esac
 505   fi
 506   AC_MSG_RESULT([${ld_shlibs}])
 507   if test "$ld_shlibs" = "no"; then
 508     can_build_shared=no
 509   fi
 510 fi # End of if cc_produces_so = no
 511
 512 dnl
 513 dnl Last thing, check how to get a linked executable to have its symbols
 514 dnl exported, so that the modules have access to them.
 515 dnl
 516 dnl XEmacs FIXME - we need to set ld_dynamic_link_flags properly for
 517 dnl most of these systems, which was missing from libtool. I know they
 518 dnl all have a way of doing this, but someone needs to look at this
 519 dnl for each OS and make sure it is correct. Remember that the arguments
 520 dnl are passed when temacs is linked, this is NOT for modules. The sole
 521 dnl purpose of the argument is to get the internal XEmacs symbols exposed
 522 dnl for modules to use. This means that the COMPILER (and NOT the linker)
 523 dnl is most often used to create temacs, so arguments to the linker will
 524 dnl usually need to be prefix with ${wl} or some other such thing.
 525 dnl
 526
 527 if test "$xe_gnu_ld" = yes; then
 528   if test "$ld_shlibs" = yes; then
 529     ld_dynamic_link_flags="${wl}-export-dynamic"
 530   fi
 531 fi
 532
 533 if test -z "$ld_dynamic_link_flags"; then
 534   case "$xehost_os" in
 535   aix3*)
 536     ld_dynamic_link_flags=
 537     ;;
 538
 539   aix4*)
 540     ld_dynamic_link_flags=
 541     ;;
 542
 543   freebsd2.2*)
 544     ld_dynamic_link_flags=
 545     ;;
 546
 547   freebsd2*)
 548     ld_dynamic_link_flags=
 549     ;;
 550
 551   freebsd3*)
 552     ld_dynamic_link_flags=
 553     ;;
 554
 555   hpux*)
 556     ld_dynamic_link_flags="${wl}-E"
 557     ;;
 558
 559   irix5* | irix6*)
 560     ld_dynamic_link_flags=
 561     ;;
 562
 563   netbsd*)
 564     ld_dynamic_link_flags=
 565     ;;
 566
 567   openbsd*)
 568     ld_dynamic_link_flags=
 569     ;;
 570
 571   osf3* | osf4*)
 572     ld_dynamic_link_flags=
 573     ;;
 574
 575   solaris2* | solaris7*)
 576     ld_dynamic_link_flags=
 577     ;;
 578
 579   sco3.2v5* | unixware* | sysv5* | sysv4*)
 580     ld_dynamic_link_flags="${wl}-Bexport"
 581     ;;
 582
 583   sunos4*)
 584     ld_dynamic_link_flags=
 585     ;;
 586
 587   uts4*)
 588     ld_dynamic_link_flags=
 589     ;;
 590
 591   bsdi*)
 592     ld_dynamic_link_flags=
 593     ;;
 594
 595   esac
 596 fi # End of if -z ld_dynamic_link_flags
 597 fi # End of if test "$can_build_shared" = "yes"
 598
 599 AC_SUBST(dll_ld)
 600 AC_SUBST(dll_cflags)
 601 AC_SUBST(dll_ldflags)
 602 AC_SUBST(dll_post)
 603 AC_SUBST(dll_ldo)
 604 AC_SUBST(ld_dynamic_link_flags)
 605 ])dnl
 606