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