update.
[chise/xemacs-chise.git-] / 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