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.
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
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
27 dnl $(dll_ld) $(dll_ldflags) $(dll_ldo) module.ell module.o $(dll_post)
28 dnl to create the loadable shared library.
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
35 AC_DEFUN(XE_SHLIB_STUFF,[
41 ld_dynamic_link_flags=
43 xealias=$internal_configuration
45 AC_CHECKING([how to build dynamic libraries for ${xehost}])
46 # Transform *-*-linux* to *-*-linux-gnu*, to support old configure scripts.
49 *-*-linux*) xehost=`echo $xehost | sed 's/^\(.*-.*-linux\)\(.*\)$/\1-gnu\2/'`
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/'`
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
70 # Now see if the compiler is really GCC.
71 if test "$GCC" = "yes"; then
74 AC_MSG_CHECKING(checking whether we are using GNU C)
79 ],XEGCC=yes, XEGCC=no)
80 AC_MSG_RESULT([${XEGCC}])
83 AC_MSG_CHECKING(how to produce PIC code)
87 if test "$XEGCC" = yes; then
91 aix3* | aix4* | irix5* | irix6* | osf3* | osf4*)
92 # PIC is the default for these OSes.
96 # We can build DLLs from non-PIC.
99 # FIXME: we need at least 68020 code to build shared libraries, but
100 # adding the `-m68020' flag to GCC prevents building anything better,
102 dll_cflags='-m68020 -resident32 -malways-restore-a4'
109 # PORTME Check for PIC flags for the system compiler.
112 # Is there a better link_static_flag that works with the bundled CC?
119 # PIC (with -KPIC) is the default.
123 # We can build DLLs from non-PIC.
127 # All OSF/1 code is PIC.
132 dll_cflags='-belf -Kpic'
171 if test -n "$dll_cflags"; then
172 AC_MSG_RESULT([${dll_cflags}])
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
187 fi], [AC_MSG_RESULT(no)
190 CFLAGS="$save_CFLAGS"
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.
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
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.
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.
231 dnl We dont do ANY of this if we can't produce shared objects.
233 if test "$can_build_shared" = "yes"; then
237 AC_MSG_CHECKING(if C compiler can produce shared libraries)
238 if test "$XEGCC" = yes; then
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"
248 freebsd2* | netbsd* | openbsd*)
250 xcldf="${wl}-Bshareable"
259 xcldf="${wl}-b ${wl}+s"
262 irix5* | irix6* | osf3* | osf4*)
267 sco3.2v5* | unixware* | sysv5* | sysv4* | solaris2* | solaris7* | uts4*)
273 xcldf="${wl}-assert ${wl}pure-text ${wl}-Bstatic"
274 xldf="-assert pure-text -Bstatic"
277 fi # End if if we are using gcc
279 if test -n "$xcldf"; then
280 save_LDFLAGS=$LDFLAGS
282 save_xe_libs=$xe_libs
283 LDFLAGS="$xcldf $LDFLAGS"
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
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'
295 AC_MSG_RESULT([${cc_produces_so}])
298 if test -z "$LTLD"; then
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`
305 # Accept absolute paths.
307 if test -z "$LTLD"; then
309 *gcc-lib*) LTLD="$CC"
317 # If it fails, then pretend we aren't using GCC.
321 # If it is relative, then search for the first ld in PATH.
326 AC_MSG_CHECKING(for GNU ld)
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
348 if test -n "$LTLD"; then
349 AC_MSG_RESULT([${LTLD}])
354 if test -z "$LTLD" -a "$cc_produces_so" = no; then
355 AC_MSG_ERROR(no acceptable linker found in \$PATH)
361 dnl Order of the tests changed somewhat to prevent repetition
363 ld_dynamic_link_flags=
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
373 AC_MSG_RESULT([${xe_gnu_ld}])
377 # On these operating systems, we should treat GNU ld like the system ld.
378 gnu_ld_acts_native=yes
381 gnu_ld_acts_native=no
385 if test "$cc_produces_so" = "yes"; then
390 # OK - only NOW do we futz about with ld.
391 # See if the linker supports building shared libraries.
392 AC_MSG_CHECKING(whether the linker supports shared libraries)
397 if test "$xe_gnu_ld" = yes && test "$gnu_ld_acts_native" != yes; then
398 # See if GNU ld supports shared libraries.
399 if $LTLD --help 2>&1 | egrep ': supported targets:.* elf' > /dev/null; then
401 dll_ldflags="-shared"
407 # PORTME fill in a description of your system's linker (not GNU ld)
418 # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor
419 # support. Future versions do this automatically, but an explicit c++rt0.o
420 # doesn't break anything, and helps significantly (at the cost of a little
425 dll_post="/usr/lib/c++rt0.o"
428 # Unfortunately, older versions of FreeBSD 2 don't have this feature.
431 dll_ldflags="-Bshareable"
434 # FreeBSD 3, at last, uses gcc -shared to do shared libraries.
436 dll_ldflags="-shared"
450 # Tested with NetBSD 1.2 ld
465 # For both SCO and Solaris we MAY want to have LDFLAGS include -z text
466 sco3.2v5* | unixware* | sysv5* | sysv4* | solaris2* | solaris7*)
469 *gcc*) dll_ldflags="-shared"
478 if test "$XEGCC" = yes; then
502 AC_MSG_RESULT([${ld_shlibs}])
503 if test "$ld_shlibs" = "no"; then
506 fi # End of if cc_produces_so = no
509 dnl Last thing, check how to get a linked executable to have its symbols
510 dnl exported, so that the modules have access to them.
512 dnl XEmacs FIXME - we need to set ld_dynamic_link_flags propperly for
513 dnl most of these systems, which was missing from libtool. I know they
514 dnl all have a way of doing this, but someone needs to look at this
515 dnl for each OS and make sure it is correct. Remember that the arguments
516 dnl are passed when temacs is linked, this is NOT for modules. The sole
517 dnl purpose of the argument is to get the internal XEmacs symbols exposed
518 dnl for modules to use. This means that the COMPILER (and NOT the linker)
519 dnl is most often used to create temacs, so arguments to the linker will
520 dnl usually need to be prefix with ${wl} or some other such thing.
523 if test "$xe_gnu_ld" = yes; then
524 if test "$ld_shlibs" = yes; then
525 ld_dynamic_link_flags="${wl}-export-dynamic"
529 if test -z "$ld_dynamic_link_flags"; then
532 ld_dynamic_link_flags=
536 ld_dynamic_link_flags=
540 ld_dynamic_link_flags=
544 ld_dynamic_link_flags=
548 ld_dynamic_link_flags=
552 ld_dynamic_link_flags="${wl}-E"
556 ld_dynamic_link_flags=
560 ld_dynamic_link_flags=
564 ld_dynamic_link_flags=
568 ld_dynamic_link_flags=
571 solaris2* | solaris7*)
572 ld_dynamic_link_flags="${wl}-Bdynamic"
575 sco3.2v5* | unixware* | sysv5* | sysv4*)
576 ld_dynamic_link_flags="${wl}-Bexport"
580 ld_dynamic_link_flags=
584 ld_dynamic_link_flags=
588 ld_dynamic_link_flags=
592 fi # End of if -z ld_dynamic_link_flags
593 fi # End of if test "$can_build_shared" = "yes"
597 AC_SUBST(dll_ldflags)
600 AC_SUBST(ld_dynamic_link_flags)