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