From a4334498bba8c0b47266e5ddbb65f116352657a2 Mon Sep 17 00:00:00 2001 From: megacz Date: Fri, 30 Jan 2004 07:15:38 +0000 Subject: [PATCH] 2003/09/13 05:00:51 darcs-hash:20040130071538-2ba56-b30bd2b7f2e11709d2f7bf9abc346cb9ac9d2d28.gz --- upstream/gcc-3.3/patches/darwin-gc.patch |27654 ++++++++++++++++++++++++++++++ 1 file changed, 27654 insertions(+) create mode 100644 upstream/gcc-3.3/patches/darwin-gc.patch diff --git a/upstream/gcc-3.3/patches/darwin-gc.patch b/upstream/gcc-3.3/patches/darwin-gc.patch new file mode 100644 index 0000000..2eaf14c --- /dev/null +++ b/upstream/gcc-3.3/patches/darwin-gc.patch @@ -0,0 +1,27654 @@ +diff -urNb boehm-gc/ChangeLog boehm-gc/ChangeLog +--- boehm-gc/ChangeLog Tue May 13 17:08:56 2003 ++++ boehm-gc/ChangeLog Tue Jan 21 22:02:28 2003 +@@ -1,69 +1,3 @@ +-2003-05-13 Release Manager +- +- * GCC 3.3 Released. +- +-2003-05-13 Release Manager +- +- * GCC 3.3 Released. +- +-2003-05-13 Release Manager +- +- * GCC 3.3 Released. +- +-2003-05-13 Release Manager +- +- * GCC 3.3 Released. +- +-2003-04-28 Mohan Embar +- +- * configure.in: define GC_DLL under mingw if --enable-shared +- * configure: rebuilt +- * win32_threads.c: add #ifdef GC_DLL around DllMain +- +-2003-04-09 Tom Tromey +- +- * include/private/gcconfig.h (LINUX_STACKBOTTOM): Define for +- POWERPC. +- (STACK_GRAN, HEURISTIC1): Don't define for POWERPC. +- +-2003-03-04 Hans Boehm +- * include/private/gcconfig.h (GC_data_start): declare when needed. +- * include/private/gc_priv.h: Include gcconfig.h after ptr_t +- declaration. +- +-2003-03-03 Hans Boehm +- * mark_rts.c (GC_cond_register_dynamic_libraries): add. +- (GC_push_roots): explicitly mark free list headers, register +- dynamic libraries only if !REGISTER_LIBRARIES_EARLY. +- * alloc.c (GC_stopped_mark): Conditionally call +- GC_cond_register_dynamic_libraries(). +- (GC_collect_a_little_inner, GC_try_to_collect_inner): Check GC_dont_gc. +- * dyn_load.c (GC_register_main_static_data): define. +- (GC_register_dyn_libraries (Linux /proc, Linux ELF versions)): +- no longer skip main data. Register main data for static executable. +- * misc.c (GC_REGISTER_MAIN_STATIC_DATA): define. +- (GC_init_inner): Make main data registration conditional. +- * include/private/gc_priv.h (GC_register_main_static_data): declare. +- * include/private/gcconfig.h (REGISTER_LIBRARIES_EARLY): define +- for LINUX. +- +-2003-02-20 Alexandre Oliva +- +- * configure.in: Propagate ORIGINAL_LD_FOR_MULTILIBS to +- config.status. +- * configure: Rebuilt. +- +-2003-02-11 Andreas Tobler +- +- * include/private/gcconfig.h: undefine MPROTECT_VDB for MACOSX +- +-2003-01-27 Alexandre Oliva +- +- * configure.in (toolexecdir, toolexeclibdir): Set and AC_SUBST. +- Remove USE_LIBDIR conditional. +- * Makefile.am (toolexecdir, toolexeclibdir): Don't override. +- * Makefile.in, configure: Rebuilt. +- + 2002-12-31 Tom Tromey + + For PR libgcj/8933: +diff -urNb boehm-gc/Makefile.am boehm-gc/Makefile.am +--- boehm-gc/Makefile.am Mon Jan 27 17:44:52 2003 ++++ boehm-gc/Makefile.am Mon May 26 13:08:40 2003 +@@ -16,22 +16,38 @@ + MULTIDO = true + MULTICLEAN = true + ++## Install a library built with a cross compiler in tooldir, not ++## libdir. ++if USE_LIBDIR ++toolexeclibdir = $(libdir)$(MULTISUBDIR) ++else ++toolexecdir = $(exec_prefix)/$(target_alias) ++toolexeclibdir = $(toolexecdir)/lib$(MULTISUBDIR) ++endif ++ + noinst_LTLIBRARIES = libgcjgc.la libgcjgc_convenience.la + + GC_SOURCES = allchblk.c alloc.c blacklst.c checksums.c dbg_mlc.c \ + dyn_load.c finalize.c gc_dlopen.c gcj_mlc.c headers.c irix_threads.c \ +-linux_threads.c malloc.c mallocx.c mark.c mark_rts.c misc.c new_hblk.c \ ++malloc.c mallocx.c mark.c mark_rts.c misc.c new_hblk.c \ + obj_map.c os_dep.c pcr_interface.c ptr_chck.c real_malloc.c reclaim.c \ + solaris_pthreads.c solaris_threads.c specific.c stubborn.c typd_mlc.c \ +-backgraph.c win32_threads.c ++backgraph.c win32_threads.c \ ++pthread_support.c pthread_stop_world.c darwin_stop_world.c + +-EXTRA_GC_SOURCES = alpha_mach_dep.s \ +-mips_sgi_mach_dep.S mips_ultrix_mach_dep.s powerpc_macosx_mach_dep.s \ +-rs6000_mach_dep.s sparc_mach_dep.S sparc_netbsd_mach_dep.s \ +-sparc_sunos4_mach_dep.s ia64_save_regs_in_stack.s ++EXTRA_GC_SOURCES = alpha_mach_dep.S \ ++ mips_sgi_mach_dep.S mips_ultrix_mach_dep.s powerpc_darwin_mach_dep.s \ ++ rs6000_mach_dep.s sparc_mach_dep.S sparc_netbsd_mach_dep.s \ ++ sparc_sunos4_mach_dep.s ia64_save_regs_in_stack.s ++ ++if POWERPC_DARWIN ++asm_libgc_sources = powerpc_darwin_mach_dep.s ++else ++asm_libgc_sources = ++endif + +-libgcjgc_la_SOURCES = $(GC_SOURCES) +-libgcjgc_convenience_la_SOURCES = $(GC_SOURCES) ++libgcjgc_la_SOURCES = $(GC_SOURCES) $(asm_libgc_sources) ++libgcjgc_convenience_la_SOURCES = $(GC_SOURCES) $(asm_libgc_sources) + EXTRA_libgcjgc_la_SOURCES = $(EXTRA_GC_SOURCES) + EXTRA_libgcjgc_convenience_la_SOURCES = $(EXTRA_GC_SOURCES) + +@@ -77,8 +93,6 @@ + $(AM_CPPFLAGS) $(CPPFLAGS) \ + $(AM_CFLAGS) $(MY_CFLAGS) $(GC_CFLAGS) + LINK = $(LIBTOOL) --mode=link $(CC) $(AM_CFLAGS) $(MY_CFLAGS) $(LDFLAGS) -o $@ +- +-AM_CFLAGS = @GC_CFLAGS@ + + # Work around what appears to be a GNU make bug handling MAKEFLAGS + # values defined in terms of make variables, as is the case for CC and +diff -urNb boehm-gc/Makefile.am~ boehm-gc/Makefile.am~ +--- boehm-gc/Makefile.am~ Wed Dec 31 16:00:00 1969 ++++ boehm-gc/Makefile.am~ Thu Oct 24 16:42:27 2002 +@@ -0,0 +1,159 @@ ++## Process this file with automake to produce Makefile.in. ++ ++## FIXME: `make dist' in this directory will not currently work. Many ++## files that should be in the distribution are not mentioned in this ++## Makefile.am. ++ ++AUTOMAKE_OPTIONS = cygnus ++ ++SUBDIRS = include ++ ++# Multilib support variables. ++MULTISRCTOP = ++MULTIBUILDTOP = ++MULTIDIRS = ++MULTISUBDIR = ++MULTIDO = true ++MULTICLEAN = true ++ ++## Install a library built with a cross compiler in tooldir, not ++## libdir. ++if USE_LIBDIR ++toolexeclibdir = $(libdir)$(MULTISUBDIR) ++else ++toolexecdir = $(exec_prefix)/$(target_alias) ++toolexeclibdir = $(toolexecdir)/lib$(MULTISUBDIR) ++endif ++ ++noinst_LTLIBRARIES = libgcjgc.la libgcjgc_convenience.la ++ ++GC_SOURCES = allchblk.c alloc.c blacklst.c checksums.c dbg_mlc.c \ ++dyn_load.c finalize.c gc_dlopen.c gcj_mlc.c headers.c irix_threads.c \ ++linux_threads.c malloc.c mallocx.c mark.c mark_rts.c misc.c new_hblk.c \ ++obj_map.c os_dep.c pcr_interface.c ptr_chck.c real_malloc.c reclaim.c \ ++solaris_pthreads.c solaris_threads.c specific.c stubborn.c typd_mlc.c \ ++backgraph.c win32_threads.c ++ ++EXTRA_GC_SOURCES = alpha_mach_dep.s \ ++mips_sgi_mach_dep.S mips_ultrix_mach_dep.s powerpc_macosx_mach_dep.s \ ++rs6000_mach_dep.s sparc_mach_dep.S sparc_netbsd_mach_dep.s \ ++sparc_sunos4_mach_dep.s ia64_save_regs_in_stack.s ++ ++libgcjgc_la_SOURCES = $(GC_SOURCES) ++libgcjgc_convenience_la_SOURCES = $(GC_SOURCES) ++EXTRA_libgcjgc_la_SOURCES = $(EXTRA_GC_SOURCES) ++EXTRA_libgcjgc_convenience_la_SOURCES = $(EXTRA_GC_SOURCES) ++ ++# Include THREADLIBS here to ensure that the correct versions of ++# linuxthread semaphore functions get linked: ++libgcjgc_la_LIBADD = @addobjs@ $(THREADLIBS) ++libgcjgc_la_DEPENDENCIES = @addobjs@ ++libgcjgc_la_LDFLAGS = -version-info 1:1:0 -rpath $(toolexeclibdir) ++ ++libgcjgc_convenience_la_LIBADD = @addobjs@ ++libgcjgc_convenience_la_DEPENDENCIES = @addobjs@ ++ ++AM_CXXFLAGS = @GC_CFLAGS@ ++AM_CFLAGS = @GC_CFLAGS@ ++ ++check_PROGRAMS = gctest ++# The following hack produces a warning from automake, but we need it in order ++# to build a file from a subdirectory. FIXME. ++test.o: tests/test.c ++ $(COMPILE) -c $(srcdir)/tests/test.c ++# Using $< in the above seems to fail with the HP/UX on Itanium make. ++ ++gctest_OBJECTS = test.o ++gctest_LDADD = ./libgcjgc.la $(THREADLIBS) $(EXTRA_TEST_LIBS) ++gctest_LDFLAGS = -shared-libgcc ++TESTS_ENVIRONMENT = LD_LIBRARY_PATH=../../$(MULTIBUILDTOP)gcc ++TESTS = gctest ++ ++## FIXME: relies on internal code generated by automake. ++all_objs = @addobjs@ $(libgcjgc_la_OBJECTS) ++$(all_objs) : include/private/gcconfig.h include/private/gc_priv.h \ ++include/private/gc_hdrs.h include/gc.h include/gc_gcj.h include/gc_mark.h ++ ++## FIXME: we shouldn't have to do this, but automake forces us to. ++.s.lo: ++## We use -Wp,-P to strip #line directives. Irix `as' chokes on ++## these. ++ $(LTCOMPILE) -Wp,-P -x assembler-with-cpp -c $< ++ ++## We have our own definition of LTCOMPILE because we want to use our ++## CFLAGS, not those passed in from the top level make. ++LTCOMPILE = $(LIBTOOL) --mode=compile $(CC) $(DEFS) $(INCLUDES) \ ++ $(AM_CPPFLAGS) $(CPPFLAGS) \ ++ $(AM_CFLAGS) $(MY_CFLAGS) $(GC_CFLAGS) ++LINK = $(LIBTOOL) --mode=link $(CC) $(AM_CFLAGS) $(MY_CFLAGS) $(LDFLAGS) -o $@ ++ ++AM_CFLAGS = @GC_CFLAGS@ ++ ++# Work around what appears to be a GNU make bug handling MAKEFLAGS ++# values defined in terms of make variables, as is the case for CC and ++# friends when we are called from the top level Makefile. ++AM_MAKEFLAGS = \ ++ "AR_FLAGS=$(AR_FLAGS)" \ ++ "CC_FOR_BUILD=$(CC_FOR_BUILD)" \ ++ "CFLAGS=$(CFLAGS)" \ ++ "CXXFLAGS=$(CXXFLAGS)" \ ++ "CFLAGS_FOR_BUILD=$(CFLAGS_FOR_BUILD)" \ ++ "CFLAGS_FOR_TARGET=$(CFLAGS_FOR_TARGET)" \ ++ "INSTALL=$(INSTALL)" \ ++ "INSTALL_DATA=$(INSTALL_DATA)" \ ++ "INSTALL_PROGRAM=$(INSTALL_PROGRAM)" \ ++ "INSTALL_SCRIPT=$(INSTALL_SCRIPT)" \ ++ "LDFLAGS=$(LDFLAGS)" \ ++ "LIBCFLAGS=$(LIBCFLAGS)" \ ++ "LIBCFLAGS_FOR_TARGET=$(LIBCFLAGS_FOR_TARGET)" \ ++ "MAKE=$(MAKE)" \ ++ "MAKEINFO=$(MAKEINFO) $(MAKEINFOFLAGS)" \ ++ "PICFLAG=$(PICFLAG)" \ ++ "PICFLAG_FOR_TARGET=$(PICFLAG_FOR_TARGET)" \ ++ "SHELL=$(SHELL)" \ ++ "EXPECT=$(EXPECT)" \ ++ "RUNTEST=$(RUNTEST)" \ ++ "RUNTESTFLAGS=$(RUNTESTFLAGS)" \ ++ "exec_prefix=$(exec_prefix)" \ ++ "infodir=$(infodir)" \ ++ "libdir=$(libdir)" \ ++ "prefix=$(prefix)" \ ++ "tooldir=$(tooldir)" \ ++ "AR=$(AR)" \ ++ "AS=$(AS)" \ ++ "CC=$(CC)" \ ++ "CXX=$(CXX)" \ ++ "LD=$(LD)" \ ++ "LIBCFLAGS=$(LIBCFLAGS)" \ ++ "NM=$(NM)" \ ++ "PICFLAG=$(PICFLAG)" \ ++ "RANLIB=$(RANLIB)" \ ++ "DESTDIR=$(DESTDIR)" ++ ++CONFIG_STATUS_DEPENDENCIES = $(srcdir)/configure.host ++ ++# Multilib support. ++.PHONY: all-multi mostlyclean-multi clean-multi distclean-multi \ ++ maintainer-clean-multi ++ ++all-am: all-multi ++install-am: install-multi ++mostlyclean-am: mostlyclean-multi ++clean-am: clean-multi ++distclean-am: distclean-multi ++maintainer-clean-am: maintainer-clean-multi ++ ++all-multi: ++ : $(MAKE) ; exec $(MULTIDO) $(AM_MAKEFLAGS) DO=all multi-do ++install-multi: ++ $(MULTIDO) $(AM_MAKEFLAGS) DO=install multi-do ++mostlyclean-multi: ++ $(MULTICLEAN) $(AM_MAKEFLAGS) DO=mostlyclean multi-clean ++clean-multi: ++ $(MULTICLEAN) $(AM_MAKEFLAGS) DO=clean multi-clean ++distclean-multi: ++ $(MULTICLEAN) $(AM_MAKEFLAGS) DO=distclean multi-clean ++maintainer-clean-multi: ++ $(MULTICLEAN) $(AM_MAKEFLAGS) DO=maintainer-clean multi-clean ++ ++MAKEOVERRIDES= +diff -urNb boehm-gc/Makefile.in boehm-gc/Makefile.in +--- boehm-gc/Makefile.in Tue May 13 17:18:14 2003 ++++ boehm-gc/Makefile.in Mon May 26 13:08:48 2003 +@@ -1,6 +1,8 @@ +-# Makefile.in generated automatically by automake 1.4 from Makefile.am ++# Makefile.in generated by automake 1.6.3 from Makefile.am. ++# @configure_input@ + +-# Copyright (C) 1994, 1995-8, 1999 Free Software Foundation, Inc. ++# Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 ++# Free Software Foundation, Inc. + # This Makefile.in is free software; the Free Software Foundation + # gives unlimited permission to copy and/or distribute it, + # with or without modifications, as long as this notice is preserved. +@@ -10,7 +12,7 @@ + # even the implied warranty of MERCHANTABILITY or FITNESS FOR A + # PARTICULAR PURPOSE. + +- ++@SET_MAKE@ + SHELL = @SHELL@ + + srcdir = @srcdir@ +@@ -31,13 +33,9 @@ + mandir = @mandir@ + includedir = @includedir@ + oldincludedir = /usr/include +- +-DESTDIR = +- + pkgdatadir = $(datadir)/@PACKAGE@ + pkglibdir = $(libdir)/@PACKAGE@ + pkgincludedir = $(includedir)/@PACKAGE@ +- + top_builddir = . + + ACLOCAL = @ACLOCAL@ +@@ -45,12 +43,16 @@ + AUTOMAKE = @AUTOMAKE@ + AUTOHEADER = @AUTOHEADER@ + ++am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd + INSTALL = @INSTALL@ +-INSTALL_PROGRAM = @INSTALL_PROGRAM@ $(AM_INSTALL_PROGRAM_FLAGS) ++INSTALL_PROGRAM = @INSTALL_PROGRAM@ + INSTALL_DATA = @INSTALL_DATA@ ++install_sh_DATA = $(install_sh) -c -m 644 ++install_sh_PROGRAM = $(install_sh) -c ++install_sh_SCRIPT = $(install_sh) -c + INSTALL_SCRIPT = @INSTALL_SCRIPT@ ++INSTALL_HEADER = $(INSTALL_DATA) + transform = @program_transform_name@ +- + NORMAL_INSTALL = : + PRE_INSTALL = : + POST_INSTALL = : +@@ -63,38 +65,48 @@ + host_triplet = @host@ + target_alias = @target_alias@ + target_triplet = @target@ ++ ++EXEEXT = @EXEEXT@ ++OBJEXT = @OBJEXT@ ++PATH_SEPARATOR = @PATH_SEPARATOR@ ++AMTAR = @AMTAR@ + AR = @AR@ + AS = @AS@ ++AWK = @AWK@ + CC = @CC@ + CPP = @CPP@ + CXX = @CXX@ + CXXCPP = @CXXCPP@ + CXXINCLUDES = @CXXINCLUDES@ ++DEPDIR = @DEPDIR@ + DLLTOOL = @DLLTOOL@ +-EXEEXT = @EXEEXT@ ++ECHO = @ECHO@ ++EGREP = @EGREP@ + EXTRA_TEST_LIBS = @EXTRA_TEST_LIBS@ ++F77 = @F77@ + GCJ = @GCJ@ + GCJFLAGS = @GCJFLAGS@ + GC_CFLAGS = @GC_CFLAGS@ + INCLUDES = @INCLUDES@ ++INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ + LIBTOOL = @LIBTOOL@ + LN_S = @LN_S@ + MAINT = @MAINT@ +-MAKEINFO = @MAKEINFO@ + MY_CFLAGS = @MY_CFLAGS@ + OBJDUMP = @OBJDUMP@ +-OBJEXT = @OBJEXT@ + PACKAGE = @PACKAGE@ + RANLIB = @RANLIB@ ++RC = @RC@ + STRIP = @STRIP@ + THREADLIBS = @THREADLIBS@ + VERSION = @VERSION@ + addobjs = @addobjs@ ++am__include = @am__include@ ++am__quote = @am__quote@ + gc_basedir = @gc_basedir@ ++install_sh = @install_sh@ + mkinstalldirs = @mkinstalldirs@ + target_all = @target_all@ +-toolexecdir = @toolexecdir@ +-toolexeclibdir = @toolexeclibdir@ + + AUTOMAKE_OPTIONS = cygnus + +@@ -108,24 +120,32 @@ + MULTIDO = true + MULTICLEAN = true + ++@USE_LIBDIR_TRUE@toolexeclibdir = $(libdir)$(MULTISUBDIR) ++@USE_LIBDIR_FALSE@toolexeclibdir = $(toolexecdir)/lib$(MULTISUBDIR) ++@USE_LIBDIR_FALSE@toolexecdir = $(exec_prefix)/$(target_alias) ++ + noinst_LTLIBRARIES = libgcjgc.la libgcjgc_convenience.la + + GC_SOURCES = allchblk.c alloc.c blacklst.c checksums.c dbg_mlc.c \ + dyn_load.c finalize.c gc_dlopen.c gcj_mlc.c headers.c irix_threads.c \ +-linux_threads.c malloc.c mallocx.c mark.c mark_rts.c misc.c new_hblk.c \ ++malloc.c mallocx.c mark.c mark_rts.c misc.c new_hblk.c \ + obj_map.c os_dep.c pcr_interface.c ptr_chck.c real_malloc.c reclaim.c \ + solaris_pthreads.c solaris_threads.c specific.c stubborn.c typd_mlc.c \ +-backgraph.c win32_threads.c ++backgraph.c win32_threads.c \ ++pthread_support.c pthread_stop_world.c darwin_stop_world.c ++ + ++EXTRA_GC_SOURCES = alpha_mach_dep.S \ ++ mips_sgi_mach_dep.S mips_ultrix_mach_dep.s powerpc_darwin_mach_dep.s \ ++ rs6000_mach_dep.s sparc_mach_dep.S sparc_netbsd_mach_dep.s \ ++ sparc_sunos4_mach_dep.s ia64_save_regs_in_stack.s + +-EXTRA_GC_SOURCES = alpha_mach_dep.s \ +-mips_sgi_mach_dep.S mips_ultrix_mach_dep.s powerpc_macosx_mach_dep.s \ +-rs6000_mach_dep.s sparc_mach_dep.S sparc_netbsd_mach_dep.s \ +-sparc_sunos4_mach_dep.s ia64_save_regs_in_stack.s + ++@POWERPC_DARWIN_TRUE@asm_libgc_sources = powerpc_darwin_mach_dep.s ++@POWERPC_DARWIN_FALSE@asm_libgc_sources = + +-libgcjgc_la_SOURCES = $(GC_SOURCES) +-libgcjgc_convenience_la_SOURCES = $(GC_SOURCES) ++libgcjgc_la_SOURCES = $(GC_SOURCES) $(asm_libgc_sources) ++libgcjgc_convenience_la_SOURCES = $(GC_SOURCES) $(asm_libgc_sources) + EXTRA_libgcjgc_la_SOURCES = $(EXTRA_GC_SOURCES) + EXTRA_libgcjgc_convenience_la_SOURCES = $(EXTRA_GC_SOURCES) + +@@ -139,12 +159,11 @@ + libgcjgc_convenience_la_DEPENDENCIES = @addobjs@ + + AM_CXXFLAGS = @GC_CFLAGS@ +- + AM_CFLAGS = @GC_CFLAGS@ + + check_PROGRAMS = gctest +-# Using $< in the above seems to fail with the HP/UX on Itanium make. + ++# Using $< in the above seems to fail with the HP/UX on Itanium make. + gctest_OBJECTS = test.o + gctest_LDADD = ./libgcjgc.la $(THREADLIBS) $(EXTRA_TEST_LIBS) + gctest_LDFLAGS = -shared-libgcc +@@ -204,104 +223,127 @@ + CONFIG_STATUS_DEPENDENCIES = $(srcdir)/configure.host + + MAKEOVERRIDES = ++subdir = . + ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 + CONFIG_CLEAN_FILES = + LTLIBRARIES = $(noinst_LTLIBRARIES) + ++am__objects_1 = allchblk.lo alloc.lo blacklst.lo checksums.lo dbg_mlc.lo \ ++ dyn_load.lo finalize.lo gc_dlopen.lo gcj_mlc.lo headers.lo \ ++ irix_threads.lo malloc.lo mallocx.lo mark.lo mark_rts.lo \ ++ misc.lo new_hblk.lo obj_map.lo os_dep.lo pcr_interface.lo \ ++ ptr_chck.lo real_malloc.lo reclaim.lo solaris_pthreads.lo \ ++ solaris_threads.lo specific.lo stubborn.lo typd_mlc.lo \ ++ backgraph.lo win32_threads.lo pthread_support.lo \ ++ pthread_stop_world.lo darwin_stop_world.lo ++@POWERPC_DARWIN_TRUE@am__objects_2 = powerpc_darwin_mach_dep.lo ++@POWERPC_DARWIN_FALSE@am__objects_2 = ++am_libgcjgc_la_OBJECTS = $(am__objects_1) $(am__objects_2) ++libgcjgc_la_OBJECTS = $(am_libgcjgc_la_OBJECTS) ++libgcjgc_convenience_la_LDFLAGS = ++am_libgcjgc_convenience_la_OBJECTS = $(am__objects_1) $(am__objects_2) ++libgcjgc_convenience_la_OBJECTS = $(am_libgcjgc_convenience_la_OBJECTS) ++check_PROGRAMS = gctest$(EXEEXT) ++gctest_DEPENDENCIES = ./libgcjgc.la + +-DEFS = @DEFS@ -I. -I$(srcdir) ++DEFS = @DEFS@ ++DEFAULT_INCLUDES = -I. -I$(srcdir) + CPPFLAGS = @CPPFLAGS@ + LDFLAGS = @LDFLAGS@ + LIBS = @LIBS@ +-libgcjgc_la_OBJECTS = allchblk.lo alloc.lo blacklst.lo checksums.lo \ +-dbg_mlc.lo dyn_load.lo finalize.lo gc_dlopen.lo gcj_mlc.lo headers.lo \ +-irix_threads.lo linux_threads.lo malloc.lo mallocx.lo mark.lo \ +-mark_rts.lo misc.lo new_hblk.lo obj_map.lo os_dep.lo pcr_interface.lo \ +-ptr_chck.lo real_malloc.lo reclaim.lo solaris_pthreads.lo \ +-solaris_threads.lo specific.lo stubborn.lo typd_mlc.lo backgraph.lo \ +-win32_threads.lo +-libgcjgc_convenience_la_LDFLAGS = +-libgcjgc_convenience_la_OBJECTS = allchblk.lo alloc.lo blacklst.lo \ +-checksums.lo dbg_mlc.lo dyn_load.lo finalize.lo gc_dlopen.lo gcj_mlc.lo \ +-headers.lo irix_threads.lo linux_threads.lo malloc.lo mallocx.lo \ +-mark.lo mark_rts.lo misc.lo new_hblk.lo obj_map.lo os_dep.lo \ +-pcr_interface.lo ptr_chck.lo real_malloc.lo reclaim.lo \ +-solaris_pthreads.lo solaris_threads.lo specific.lo stubborn.lo \ +-typd_mlc.lo backgraph.lo win32_threads.lo +-check_PROGRAMS = gctest$(EXEEXT) +-gctest_DEPENDENCIES = ./libgcjgc.la +-CFLAGS = @CFLAGS@ +-COMPILE = $(CC) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) ++depcomp = ++am__depfiles_maybe = ++CCASCOMPILE = $(CCAS) $(AM_CCASFLAGS) $(CCASFLAGS) ++LTCCASCOMPILE = $(LIBTOOL) --mode=compile $(CCAS) $(AM_CCASFLAGS) \ ++ $(CCASFLAGS) ++CCASFLAGS = @CCASFLAGS@ ++COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \ ++ $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) + CCLD = $(CC) +-DIST_COMMON = ChangeLog Makefile.am Makefile.in acinclude.m4 aclocal.m4 \ +-config.guess config.sub configure configure.in install-sh ltconfig \ +-ltmain.sh mkinstalldirs +- +- +-DISTFILES = $(DIST_COMMON) $(SOURCES) $(HEADERS) $(TEXINFOS) $(EXTRA_DIST) +- +-TAR = gtar +-GZIP_ENV = --best ++CFLAGS = @CFLAGS@ ++DIST_SOURCES = $(libgcjgc_la_SOURCES) $(EXTRA_libgcjgc_la_SOURCES) \ ++ $(libgcjgc_convenience_la_SOURCES) \ ++ $(EXTRA_libgcjgc_convenience_la_SOURCES) ++ ++RECURSIVE_TARGETS = info-recursive dvi-recursive \ ++ uninstall-info-recursive all-recursive install-data-recursive \ ++ install-exec-recursive installdirs-recursive install-recursive \ ++ uninstall-recursive check-recursive installcheck-recursive + SOURCES = $(libgcjgc_la_SOURCES) $(EXTRA_libgcjgc_la_SOURCES) $(libgcjgc_convenience_la_SOURCES) $(EXTRA_libgcjgc_convenience_la_SOURCES) +-OBJECTS = $(libgcjgc_la_OBJECTS) $(libgcjgc_convenience_la_OBJECTS) + +-all: all-redirect ++all: all-recursive ++ + .SUFFIXES: + .SUFFIXES: .S .c .lo .o .obj .s +-$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ Makefile.am $(top_srcdir)/configure.in $(ACLOCAL_M4) +- cd $(top_srcdir) && $(AUTOMAKE) --cygnus Makefile + +-Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status +- cd $(top_builddir) \ +- && CONFIG_FILES=$@ CONFIG_HEADERS= $(SHELL) ./config.status +- +-$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ configure.in acinclude.m4 +- cd $(srcdir) && $(ACLOCAL) ++am__CONFIG_DISTCLEAN_FILES = config.status config.cache config.log \ ++ configure.lineno ++$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ Makefile.am $(top_srcdir)/configure.in $(ACLOCAL_M4) ++ cd $(top_srcdir) && \ ++ $(AUTOMAKE) --cygnus Makefile ++Makefile: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.in $(top_builddir)/config.status ++ cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe) + +-config.status: $(srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) ++$(top_builddir)/config.status: $(srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + $(SHELL) ./config.status --recheck +-$(srcdir)/configure: @MAINTAINER_MODE_TRUE@$(srcdir)/configure.in $(ACLOCAL_M4) $(CONFIGURE_DEPENDENCIES) ++$(srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(srcdir)/configure.in $(ACLOCAL_M4) $(CONFIGURE_DEPENDENCIES) + cd $(srcdir) && $(AUTOCONF) + +-mostlyclean-noinstLTLIBRARIES: ++$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ configure.in acinclude.m4 ++ cd $(srcdir) && $(ACLOCAL) $(ACLOCAL_AMFLAGS) + + clean-noinstLTLIBRARIES: + -test -z "$(noinst_LTLIBRARIES)" || rm -f $(noinst_LTLIBRARIES) ++ @list='$(noinst_LTLIBRARIES)'; for p in $$list; do \ ++ dir="`echo $$p | sed -e 's|/[^/]*$$||'`"; \ ++ test -z "$dir" && dir=.; \ ++ echo "rm -f \"$${dir}/so_locations\""; \ ++ rm -f "$${dir}/so_locations"; \ ++ done ++libgcjgc.la: $(libgcjgc_la_OBJECTS) $(libgcjgc_la_DEPENDENCIES) ++ $(LINK) $(libgcjgc_la_LDFLAGS) $(libgcjgc_la_OBJECTS) $(libgcjgc_la_LIBADD) $(LIBS) ++libgcjgc_convenience.la: $(libgcjgc_convenience_la_OBJECTS) $(libgcjgc_convenience_la_DEPENDENCIES) ++ $(LINK) $(libgcjgc_convenience_la_LDFLAGS) $(libgcjgc_convenience_la_OBJECTS) $(libgcjgc_convenience_la_LIBADD) $(LIBS) + +-distclean-noinstLTLIBRARIES: +- +-maintainer-clean-noinstLTLIBRARIES: +- +-.c.o: +- $(COMPILE) -c $< ++clean-checkPROGRAMS: ++ @list='$(check_PROGRAMS)'; for p in $$list; do \ ++ f=`echo $$p|sed 's/$(EXEEXT)$$//'`; \ ++ echo " rm -f $$p $$f"; \ ++ rm -f $$p $$f ; \ ++ done ++gctest$(EXEEXT): $(gctest_OBJECTS) $(gctest_DEPENDENCIES) ++ @rm -f gctest$(EXEEXT) ++ $(LINK) $(gctest_LDFLAGS) $(gctest_OBJECTS) $(gctest_LDADD) $(LIBS) + +-# FIXME: We should only use cygpath when building on Windows, +-# and only if it is available. +-.c.obj: +- $(COMPILE) -c `cygpath -w $<` ++mostlyclean-compile: ++ -rm -f *.$(OBJEXT) core *.core + +-.s.o: +- $(COMPILE) -c $< ++distclean-compile: ++ -rm -f *.tab.c + + .S.o: +- $(COMPILE) -c $< ++ $(CCASCOMPILE) -c `test -f '$<' || echo '$(srcdir)/'`$< + +-mostlyclean-compile: +- -rm -f *.o core *.core +- -rm -f *.$(OBJEXT) ++.S.obj: ++ $(CCASCOMPILE) -c `cygpath -w $<` + +-clean-compile: ++.S.lo: ++ $(LTCCASCOMPILE) -c -o $@ `test -f '$<' || echo '$(srcdir)/'`$< + +-distclean-compile: +- -rm -f *.tab.c ++.c.o: ++ $(COMPILE) -c `test -f '$<' || echo '$(srcdir)/'`$< + +-maintainer-clean-compile: ++.c.obj: ++ $(COMPILE) -c `cygpath -w $<` + + .c.lo: +- $(LIBTOOL) --mode=compile $(COMPILE) -c $< ++ $(LTCOMPILE) -c -o $@ `test -f '$<' || echo '$(srcdir)/'`$< + +-.S.lo: +- $(LIBTOOL) --mode=compile $(COMPILE) -c $< ++.s.o: ++ $(CCASCOMPILE) -c `test -f '$<' || echo '$(srcdir)/'`$< ++ ++.s.obj: ++ $(CCASCOMPILE) -c `cygpath -w $<` + + mostlyclean-libtool: + -rm -f *.lo +@@ -310,27 +352,8 @@ + -rm -rf .libs _libs + + distclean-libtool: +- +-maintainer-clean-libtool: +- +-libgcjgc.la: $(libgcjgc_la_OBJECTS) $(libgcjgc_la_DEPENDENCIES) +- $(LINK) $(libgcjgc_la_LDFLAGS) $(libgcjgc_la_OBJECTS) $(libgcjgc_la_LIBADD) $(LIBS) +- +-libgcjgc_convenience.la: $(libgcjgc_convenience_la_OBJECTS) $(libgcjgc_convenience_la_DEPENDENCIES) +- $(LINK) $(libgcjgc_convenience_la_LDFLAGS) $(libgcjgc_convenience_la_OBJECTS) $(libgcjgc_convenience_la_LIBADD) $(LIBS) +- +-mostlyclean-checkPROGRAMS: +- +-clean-checkPROGRAMS: +- -test -z "$(check_PROGRAMS)" || rm -f $(check_PROGRAMS) +- +-distclean-checkPROGRAMS: +- +-maintainer-clean-checkPROGRAMS: +- +-gctest$(EXEEXT): $(gctest_OBJECTS) $(gctest_DEPENDENCIES) +- @rm -f gctest$(EXEEXT) +- $(LINK) $(gctest_LDFLAGS) $(gctest_OBJECTS) $(gctest_LDADD) $(LIBS) ++ -rm -f libtool ++uninstall-info-am: + + # This directory's subdirectories are mostly independent; you can cd + # into them and run `make' without going through this Makefile. +@@ -338,13 +361,8 @@ + # (1) if the variable is set in `config.status', edit `config.status' + # (which will cause the Makefiles to be regenerated when you run `make'); + # (2) otherwise, pass the desired values on the `make' command line. +- +-@SET_MAKE@ +- +-all-recursive install-data-recursive install-exec-recursive \ +-installdirs-recursive install-recursive uninstall-recursive install-info-recursive \ +-check-recursive installcheck-recursive info-recursive dvi-recursive: +- @set fnord $(MAKEFLAGS); amf=$$2; \ ++$(RECURSIVE_TARGETS): ++ @set fnord $$MAKEFLAGS; amf=$$2; \ + dot_seen=no; \ + target=`echo $@ | sed s/-recursive//`; \ + list='$(SUBDIRS)'; for subdir in $$list; do \ +@@ -364,13 +382,18 @@ + + mostlyclean-recursive clean-recursive distclean-recursive \ + maintainer-clean-recursive: +- @set fnord $(MAKEFLAGS); amf=$$2; \ ++ @set fnord $$MAKEFLAGS; amf=$$2; \ + dot_seen=no; \ +- rev=''; list='$(SUBDIRS)'; for subdir in $$list; do \ ++ case "$@" in \ ++ distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \ ++ *) list='$(SUBDIRS)' ;; \ ++ esac; \ ++ rev=''; for subdir in $$list; do \ ++ if test "$$subdir" = "."; then :; else \ + rev="$$subdir $$rev"; \ +- test "$$subdir" = "." && dot_seen=yes; \ ++ fi; \ + done; \ +- test "$$dot_seen" = "no" && rev=". $$rev"; \ ++ rev="$$rev ."; \ + target=`echo $@ | sed s/-recursive//`; \ + for subdir in $$rev; do \ + echo "Making $$target in $$subdir"; \ +@@ -387,17 +410,22 @@ + test "$$subdir" = . || (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) tags); \ + done + ++ETAGS = etags ++ETAGSFLAGS = ++ + tags: TAGS + +-ID: $(HEADERS) $(SOURCES) $(LISP) +- list='$(SOURCES) $(HEADERS)'; \ +- unique=`for i in $$list; do echo $$i; done | \ +- awk ' { files[$$0] = 1; } \ ++ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES) ++ list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ ++ unique=`for i in $$list; do \ ++ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ ++ done | \ ++ $(AWK) ' { files[$$0] = 1; } \ + END { for (i in files) print i; }'`; \ +- here=`pwd` && cd $(srcdir) \ +- && mkid -f$$here/ID $$unique $(LISP) ++ mkid -fID $$unique + +-TAGS: tags-recursive $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) $(LISP) ++TAGS: tags-recursive $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ ++ $(TAGS_FILES) $(LISP) + tags=; \ + here=`pwd`; \ + list='$(SUBDIRS)'; for subdir in $$list; do \ +@@ -405,193 +433,163 @@ + test -f $$subdir/TAGS && tags="$$tags -i $$here/$$subdir/TAGS"; \ + fi; \ + done; \ +- list='$(SOURCES) $(HEADERS)'; \ +- unique=`for i in $$list; do echo $$i; done | \ +- awk ' { files[$$0] = 1; } \ ++ list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ ++ unique=`for i in $$list; do \ ++ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ ++ done | \ ++ $(AWK) ' { files[$$0] = 1; } \ + END { for (i in files) print i; }'`; \ +- test -z "$(ETAGS_ARGS)$$unique$(LISP)$$tags" \ +- || (cd $(srcdir) && etags $(ETAGS_ARGS) $$tags $$unique $(LISP) -o $$here/TAGS) +- +-mostlyclean-tags: +- +-clean-tags: ++ test -z "$(ETAGS_ARGS)$$tags$$unique" \ ++ || $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ ++ $$tags $$unique ++ ++GTAGS: ++ here=`$(am__cd) $(top_builddir) && pwd` \ ++ && cd $(top_srcdir) \ ++ && gtags -i $(GTAGS_ARGS) $$here + + distclean-tags: +- -rm -f TAGS ID ++ -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH + +-maintainer-clean-tags: +- +-distdir = $(PACKAGE)-$(VERSION) +-top_distdir = $(distdir) +- +-# This target untars the dist file and tries a VPATH configuration. Then +-# it guarantees that the distribution is self-contained by making another +-# tarfile. +-distcheck: dist +- -rm -rf $(distdir) +- GZIP=$(GZIP_ENV) $(TAR) zxf $(distdir).tar.gz +- mkdir $(distdir)/=build +- mkdir $(distdir)/=inst +- dc_install_base=`cd $(distdir)/=inst && pwd`; \ +- cd $(distdir)/=build \ +- && ../configure --srcdir=.. --prefix=$$dc_install_base \ +- && $(MAKE) $(AM_MAKEFLAGS) \ +- && $(MAKE) $(AM_MAKEFLAGS) dvi \ +- && $(MAKE) $(AM_MAKEFLAGS) check \ +- && $(MAKE) $(AM_MAKEFLAGS) install \ +- && $(MAKE) $(AM_MAKEFLAGS) installcheck \ +- && $(MAKE) $(AM_MAKEFLAGS) dist +- -rm -rf $(distdir) +- @banner="$(distdir).tar.gz is ready for distribution"; \ +- dashes=`echo "$$banner" | sed s/./=/g`; \ +- echo "$$dashes"; \ +- echo "$$banner"; \ +- echo "$$dashes" +-dist: distdir +- -chmod -R a+r $(distdir) +- GZIP=$(GZIP_ENV) $(TAR) chozf $(distdir).tar.gz $(distdir) +- -rm -rf $(distdir) +-dist-all: distdir +- -chmod -R a+r $(distdir) +- GZIP=$(GZIP_ENV) $(TAR) chozf $(distdir).tar.gz $(distdir) +- -rm -rf $(distdir) +-distdir: $(DISTFILES) +- -rm -rf $(distdir) +- mkdir $(distdir) +- -chmod 777 $(distdir) +- @for file in $(DISTFILES); do \ +- if test -f $$file; then d=.; else d=$(srcdir); fi; \ +- if test -d $$d/$$file; then \ +- cp -pr $$d/$$file $(distdir)/$$file; \ +- else \ +- test -f $(distdir)/$$file \ +- || ln $$d/$$file $(distdir)/$$file 2> /dev/null \ +- || cp -p $$d/$$file $(distdir)/$$file || :; \ +- fi; \ +- done +- for subdir in $(SUBDIRS); do \ +- if test "$$subdir" = .; then :; else \ +- test -d $(distdir)/$$subdir \ +- || mkdir $(distdir)/$$subdir \ +- || exit 1; \ +- chmod 777 $(distdir)/$$subdir; \ +- (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir=../$(distdir) distdir=../$(distdir)/$$subdir distdir) \ +- || exit 1; \ +- fi; \ +- done + check-TESTS: $(TESTS) +- @failed=0; all=0; \ ++ @failed=0; all=0; xfail=0; xpass=0; \ + srcdir=$(srcdir); export srcdir; \ +- for tst in $(TESTS); do \ +- if test -f $$tst; then dir=.; \ +- else dir="$(srcdir)"; fi; \ +- if $(TESTS_ENVIRONMENT) $$dir/$$tst; then \ ++ list='$(TESTS)'; \ ++ if test -n "$$list"; then \ ++ for tst in $$list; do \ ++ if test -f ./$$tst; then dir=./; \ ++ elif test -f $$tst; then dir=; \ ++ else dir="$(srcdir)/"; fi; \ ++ if $(TESTS_ENVIRONMENT) $${dir}$$tst; then \ + all=`expr $$all + 1`; \ ++ case " $(XFAIL_TESTS) " in \ ++ *" $$tst "*) \ ++ xpass=`expr $$xpass + 1`; \ ++ failed=`expr $$failed + 1`; \ ++ echo "XPASS: $$tst"; \ ++ ;; \ ++ *) \ + echo "PASS: $$tst"; \ ++ ;; \ ++ esac; \ + elif test $$? -ne 77; then \ + all=`expr $$all + 1`; \ ++ case " $(XFAIL_TESTS) " in \ ++ *" $$tst "*) \ ++ xfail=`expr $$xfail + 1`; \ ++ echo "XFAIL: $$tst"; \ ++ ;; \ ++ *) \ + failed=`expr $$failed + 1`; \ + echo "FAIL: $$tst"; \ ++ ;; \ ++ esac; \ + fi; \ + done; \ + if test "$$failed" -eq 0; then \ ++ if test "$$xfail" -eq 0; then \ + banner="All $$all tests passed"; \ + else \ ++ banner="All $$all tests behaved as expected ($$xfail expected failures)"; \ ++ fi; \ ++ else \ ++ if test "$$xpass" -eq 0; then \ + banner="$$failed of $$all tests failed"; \ ++ else \ ++ banner="$$failed of $$all tests did not behave as expected ($$xpass unexpected passes)"; \ ++ fi; \ + fi; \ + dashes=`echo "$$banner" | sed s/./=/g`; \ + echo "$$dashes"; \ + echo "$$banner"; \ + echo "$$dashes"; \ +- test "$$failed" -eq 0 +-info-am: +-info: info-recursive +-dvi-am: +-dvi: dvi-recursive ++ test "$$failed" -eq 0; \ ++ else :; fi + check-am: $(check_PROGRAMS) + $(MAKE) $(AM_MAKEFLAGS) check-TESTS + check: check-recursive +-installcheck-am: +-installcheck: installcheck-recursive +-install-info-am: +-install-info: install-info-recursive +-install-exec-am: +-install-exec: install-exec-recursive +- +-install-data-am: +-install-data: install-data-recursive +- +-install-am: all-am +- @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am +-install: install-recursive +-uninstall-am: +-uninstall: uninstall-recursive + all-am: Makefile $(LTLIBRARIES) +-all-redirect: all-recursive +-install-strip: +- $(MAKE) $(AM_MAKEFLAGS) AM_INSTALL_PROGRAM_FLAGS=-s install + installdirs: installdirs-recursive + installdirs-am: + ++install: install-recursive ++install-exec: install-exec-recursive ++install-data: install-data-recursive ++uninstall: uninstall-recursive + ++installcheck: installcheck-recursive ++install-strip: ++ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ ++ INSTALL_STRIP_FLAG=-s \ ++ `test -z '$(STRIP)' || \ ++ echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install + mostlyclean-generic: + + clean-generic: + + distclean-generic: + -rm -f Makefile $(CONFIG_CLEAN_FILES) +- -rm -f config.cache config.log stamp-h stamp-h[0-9]* + + maintainer-clean-generic: +-mostlyclean-am: mostlyclean-noinstLTLIBRARIES mostlyclean-compile \ +- mostlyclean-libtool mostlyclean-checkPROGRAMS \ +- mostlyclean-tags mostlyclean-generic ++ @echo "This command is intended for maintainers to use" ++ @echo "it deletes files that may require special tools to rebuild." ++clean: clean-recursive + +-mostlyclean: mostlyclean-recursive ++clean-am: clean-checkPROGRAMS clean-generic clean-libtool \ ++ clean-noinstLTLIBRARIES mostlyclean-am + +-clean-am: clean-noinstLTLIBRARIES clean-compile clean-libtool \ +- clean-checkPROGRAMS clean-tags clean-generic \ +- mostlyclean-am ++distclean: distclean-recursive ++ -rm -f $(am__CONFIG_DISTCLEAN_FILES) ++distclean-am: clean-am distclean-compile distclean-generic \ ++ distclean-libtool distclean-tags + +-clean: clean-recursive ++dvi: dvi-recursive + +-distclean-am: distclean-noinstLTLIBRARIES distclean-compile \ +- distclean-libtool distclean-checkPROGRAMS \ +- distclean-tags distclean-generic clean-am +- -rm -f libtool ++dvi-am: + +-distclean: distclean-recursive +- -rm -f config.status ++info: info-recursive + +-maintainer-clean-am: maintainer-clean-noinstLTLIBRARIES \ +- maintainer-clean-compile maintainer-clean-libtool \ +- maintainer-clean-checkPROGRAMS maintainer-clean-tags \ +- maintainer-clean-generic distclean-am +- @echo "This command is intended for maintainers to use;" +- @echo "it deletes files that may require special tools to rebuild." ++info-am: ++ ++install-data-am: ++ ++install-exec-am: ++ ++install-info: ++ ++install-man: ++ ++installcheck-am: + + maintainer-clean: maintainer-clean-recursive +- -rm -f config.status ++ -rm -f $(am__CONFIG_DISTCLEAN_FILES) ++ -rm -rf autom4te.cache ++maintainer-clean-am: distclean-am maintainer-clean-generic + +-.PHONY: mostlyclean-noinstLTLIBRARIES distclean-noinstLTLIBRARIES \ +-clean-noinstLTLIBRARIES maintainer-clean-noinstLTLIBRARIES \ +-mostlyclean-compile distclean-compile clean-compile \ +-maintainer-clean-compile mostlyclean-libtool distclean-libtool \ +-clean-libtool maintainer-clean-libtool mostlyclean-checkPROGRAMS \ +-distclean-checkPROGRAMS clean-checkPROGRAMS \ +-maintainer-clean-checkPROGRAMS install-data-recursive \ +-uninstall-data-recursive install-exec-recursive \ +-uninstall-exec-recursive installdirs-recursive uninstalldirs-recursive \ +-all-recursive check-recursive installcheck-recursive info-recursive \ +-dvi-recursive mostlyclean-recursive distclean-recursive clean-recursive \ +-maintainer-clean-recursive tags tags-recursive mostlyclean-tags \ +-distclean-tags clean-tags maintainer-clean-tags distdir check-TESTS \ +-info-am info dvi-am dvi check check-am installcheck-am installcheck \ +-install-info-am install-info install-exec-am install-exec \ +-install-data-am install-data install-am install uninstall-am uninstall \ +-all-redirect all-am all installdirs-am installdirs mostlyclean-generic \ +-distclean-generic clean-generic maintainer-clean-generic clean \ +-mostlyclean distclean maintainer-clean ++mostlyclean: mostlyclean-recursive ++ ++mostlyclean-am: mostlyclean-compile mostlyclean-generic \ ++ mostlyclean-libtool ++ ++uninstall-am: ++ ++uninstall-info: uninstall-info-recursive ++ ++.PHONY: $(RECURSIVE_TARGETS) GTAGS all all-am check check-TESTS check-am \ ++ clean clean-checkPROGRAMS clean-generic clean-libtool \ ++ clean-noinstLTLIBRARIES clean-recursive distclean \ ++ distclean-compile distclean-generic distclean-libtool \ ++ distclean-recursive distclean-tags dvi dvi-am dvi-recursive \ ++ info info-am info-recursive install install-am install-data \ ++ install-data-am install-data-recursive install-exec \ ++ install-exec-am install-exec-recursive install-info \ ++ install-info-am install-man install-recursive install-strip \ ++ installcheck installcheck-am installdirs installdirs-am \ ++ installdirs-recursive maintainer-clean maintainer-clean-generic \ ++ maintainer-clean-recursive mostlyclean mostlyclean-compile \ ++ mostlyclean-generic mostlyclean-libtool mostlyclean-recursive \ ++ tags tags-recursive uninstall uninstall-am uninstall-info-am \ ++ uninstall-info-recursive uninstall-recursive + + # The following hack produces a warning from automake, but we need it in order + # to build a file from a subdirectory. FIXME. +@@ -626,7 +624,6 @@ + $(MULTICLEAN) $(AM_MAKEFLAGS) DO=distclean multi-clean + maintainer-clean-multi: + $(MULTICLEAN) $(AM_MAKEFLAGS) DO=maintainer-clean multi-clean +- + # Tell versions [3.59,3.63) of GNU make to not export all variables. + # Otherwise a system limit (for SysV at least) may be exceeded. + .NOEXPORT: +diff -urNb boehm-gc/allchblk.c boehm-gc/allchblk.c +--- boehm-gc/allchblk.c Mon Apr 8 17:39:15 2002 ++++ boehm-gc/allchblk.c Mon May 26 12:48:52 2003 +@@ -47,12 +47,16 @@ + struct hblk * GC_hblkfreelist[N_HBLK_FLS+1] = { 0 }; + + #ifndef USE_MUNMAP ++ + word GC_free_bytes[N_HBLK_FLS+1] = { 0 }; + /* Number of free bytes on each list. */ + + /* Is bytes + the number of free bytes on lists n .. N_HBLK_FLS */ + /* > GC_max_large_allocd_bytes? */ +- GC_bool GC_enough_large_bytes_left(bytes,n) ++# ifdef __GNUC__ ++ __inline__ ++# endif ++ static GC_bool GC_enough_large_bytes_left(bytes,n) + word bytes; + int n; + { +@@ -583,11 +587,11 @@ + if (!GC_use_entire_heap + && size_avail != size_needed + && USED_HEAP_SIZE >= GC_requested_heapsize +- && !GC_incremental && GC_should_collect()) { ++ && !TRUE_INCREMENTAL && GC_should_collect()) { + # ifdef USE_MUNMAP + continue; + # else +- /* If we enough large blocks left to cover any */ ++ /* If we have enough large blocks left to cover any */ + /* previous request for large blocks, we go ahead */ + /* and split. Assuming a steady state, that should */ + /* be safe. It means that we can use the full */ +@@ -595,6 +599,12 @@ + if (!GC_enough_large_bytes_left(GC_large_allocd_bytes, n)) { + continue; + } ++ /* If we are deallocating lots of memory from */ ++ /* finalizers, fail and collect sooner rather */ ++ /* than later. */ ++ if (GC_finalizer_mem_freed > (GC_heapsize >> 4)) { ++ continue; ++ } + # endif /* !USE_MUNMAP */ + } + /* If the next heap block is obviously better, go on. */ +diff -urNb boehm-gc/alloc.c boehm-gc/alloc.c +--- boehm-gc/alloc.c Mon Mar 3 22:38:30 2003 ++++ boehm-gc/alloc.c Mon May 26 12:48:52 2003 +@@ -72,6 +72,13 @@ + GC_bool GC_need_full_gc = FALSE; + /* Need full GC do to heap growth. */ + ++#ifdef THREADS ++ GC_bool GC_world_stopped = FALSE; ++# define IF_THREADS(x) x ++#else ++# define IF_THREADS(x) ++#endif ++ + word GC_used_heap_size_after_full = 0; + + char * GC_copyright[] = +@@ -119,7 +126,6 @@ + unsigned long time_diff; + + if ((count++ & 3) != 0) return(0); +-#ifndef NO_CLOCK + GET_TIME(current_time); + time_diff = MS_TIME_DIFF(current_time,GC_start_time); + if (time_diff >= GC_time_limit) { +@@ -132,7 +138,6 @@ + # endif + return(1); + } +-#endif + return(0); + } + #endif /* !SMALL_CONFIG */ +@@ -160,7 +165,7 @@ + + (GC_large_free_bytes >> 2) + /* use a bit more of large empty heap */ + + total_root_size); +- if (GC_incremental) { ++ if (TRUE_INCREMENTAL) { + return scan_size / (2 * GC_free_space_divisor); + } else { + return scan_size / GC_free_space_divisor; +@@ -182,7 +187,8 @@ + /* managed object should not alter result, assuming the client */ + /* is playing by the rules. */ + result = (signed_word)GC_words_allocd +- - (signed_word)GC_mem_freed - expl_managed; ++ - (signed_word)GC_mem_freed ++ + (signed_word)GC_finalizer_mem_freed - expl_managed; + if (result > (signed_word)GC_words_allocd) { + result = GC_words_allocd; + /* probably client bug or unfortunate scheduling */ +@@ -250,7 +256,6 @@ + + if (GC_should_collect()) { + if (!GC_incremental) { +- GC_notify_full_gc(); + GC_gcollect_inner(); + n_partial_gcs = 0; + return; +@@ -302,10 +307,14 @@ + /* + * Stop the world garbage collection. Assumes lock held, signals disabled. + * If stop_func is not GC_never_stop_func, then abort if stop_func returns TRUE. ++ * Return TRUE if we successfully completed the collection. + */ + GC_bool GC_try_to_collect_inner(stop_func) + GC_stop_func stop_func; + { ++# ifdef CONDPRINT ++ CLOCK_TYPE start_time, current_time; ++# endif + if (GC_dont_gc) return FALSE; + if (GC_incremental && GC_collection_in_progress()) { + # ifdef CONDPRINT +@@ -320,8 +329,10 @@ + GC_collect_a_little_inner(1); + } + } ++ if (stop_func == GC_never_stop_func) GC_notify_full_gc(); + # ifdef CONDPRINT + if (GC_print_stats) { ++ if (GC_print_stats) GET_TIME(start_time); + GC_printf2( + "Initiating full world-stop collection %lu after %ld allocd bytes\n", + (unsigned long) GC_gc_no+1, +@@ -360,6 +371,13 @@ + return(FALSE); + } + GC_finish_collection(); ++# if defined(CONDPRINT) ++ if (GC_print_stats) { ++ GET_TIME(current_time); ++ GC_printf1("Complete collection took %lu msecs\n", ++ MS_TIME_DIFF(current_time,start_time)); ++ } ++# endif + return(TRUE); + } + +@@ -430,6 +448,7 @@ + result = (int)GC_collection_in_progress(); + UNLOCK(); + ENABLE_SIGNALS(); ++ if (!result && GC_debugging_started) GC_print_all_smashed(); + return(result); + } + +@@ -448,16 +467,17 @@ + CLOCK_TYPE start_time, current_time; + # endif + +-# if defined(REGISTER_LIBRARIES_EARLY) +- GC_cond_register_dynamic_libraries(); +-# endif +- STOP_WORLD(); + # ifdef PRINTTIMES + GET_TIME(start_time); + # endif + # if defined(CONDPRINT) && !defined(PRINTTIMES) + if (GC_print_stats) GET_TIME(start_time); + # endif ++# if defined(REGISTER_LIBRARIES_EARLY) ++ GC_cond_register_dynamic_libraries(); ++# endif ++ STOP_WORLD(); ++ IF_THREADS(GC_world_stopped = TRUE); + # ifdef CONDPRINT + if (GC_print_stats) { + GC_printf1("--> Marking for collection %lu ", +@@ -488,6 +508,7 @@ + } + # endif + GC_deficit = i; /* Give the mutator a chance. */ ++ IF_THREADS(GC_world_stopped = FALSE); + START_WORLD(); + return(FALSE); + } +@@ -521,6 +542,8 @@ + (*GC_check_heap)(); + } + ++ IF_THREADS(GC_world_stopped = FALSE); ++ START_WORLD(); + # ifdef PRINTTIMES + GET_TIME(current_time); + GC_printf1("World-stopped marking took %lu msecs\n", +@@ -534,7 +557,6 @@ + } + # endif + # endif +- START_WORLD(); + return(TRUE); + } + +@@ -611,6 +633,7 @@ + GC_print_address_map(); + } + # endif ++ COND_DUMP; + if (GC_find_leak) { + /* Mark all objects on the free list. All objects should be */ + /* marked when we're done. */ +@@ -707,6 +730,7 @@ + GC_words_allocd = 0; + GC_words_wasted = 0; + GC_mem_freed = 0; ++ GC_finalizer_mem_freed = 0; + + # ifdef USE_MUNMAP + GC_unmap_old(); +@@ -730,6 +754,7 @@ + int result; + DCL_LOCK_STATE; + ++ if (GC_debugging_started) GC_print_all_smashed(); + GC_INVOKE_FINALIZERS(); + DISABLE_SIGNALS(); + LOCK(); +@@ -741,14 +766,17 @@ + EXIT_GC(); + UNLOCK(); + ENABLE_SIGNALS(); +- if(result) GC_INVOKE_FINALIZERS(); ++ if(result) { ++ if (GC_debugging_started) GC_print_all_smashed(); ++ GC_INVOKE_FINALIZERS(); ++ } + return(result); + } + + void GC_gcollect GC_PROTO(()) + { +- GC_notify_full_gc(); + (void)GC_try_to_collect(GC_never_stop_func); ++ if (GC_have_errors) GC_print_all_errors(); + } + + word GC_n_heap_sects = 0; /* Number of sections currently in heap. */ +@@ -950,7 +978,6 @@ + { + if (!GC_incremental && !GC_dont_gc && + (GC_dont_expand && GC_words_allocd > 0 || GC_should_collect())) { +- GC_notify_full_gc(); + GC_gcollect_inner(); + } else { + word blocks_to_get = GC_heapsize/(HBLKSIZE*GC_free_space_divisor) +@@ -975,7 +1002,6 @@ + && !GC_expand_hp_inner(needed_blocks)) { + if (GC_fail_count++ < GC_max_retries) { + WARN("Out of Memory! Trying to continue ...\n", 0); +- GC_notify_full_gc(); + GC_gcollect_inner(); + } else { + # if !defined(AMIGA) || !defined(GC_AMIGA_FASTALLOC) +@@ -1005,14 +1031,15 @@ + word sz; + int kind; + { +- register ptr_t * flh = &(GC_obj_kinds[kind].ok_freelist[sz]); ++ ptr_t * flh = &(GC_obj_kinds[kind].ok_freelist[sz]); ++ GC_bool tried_minor = FALSE; + + if (sz == 0) return(0); + + while (*flh == 0) { + ENTER_GC(); + /* Do our share of marking work */ +- if(GC_incremental && !GC_dont_gc) GC_collect_a_little_inner(1); ++ if(TRUE_INCREMENTAL) GC_collect_a_little_inner(1); + /* Sweep blocks for objects of this size */ + GC_continue_reclaim(sz, kind); + EXIT_GC(); +@@ -1021,13 +1048,21 @@ + } + if (*flh == 0) { + ENTER_GC(); ++ if (GC_incremental && GC_time_limit == GC_TIME_UNLIMITED ++ && ! tried_minor ) { ++ GC_collect_a_little_inner(1); ++ tried_minor = TRUE; ++ } else { + if (!GC_collect_or_expand((word)1,FALSE)) { + EXIT_GC(); + return(0); + } ++ } + EXIT_GC(); + } + } ++ /* Successful allocation; reset failure count. */ ++ GC_fail_count = 0; + + return(*flh); + } +diff -urNb boehm-gc/alpha_mach_dep.s boehm-gc/alpha_mach_dep.s +--- boehm-gc/alpha_mach_dep.s Fri Aug 17 11:30:45 2001 ++++ boehm-gc/alpha_mach_dep.s Mon May 26 12:48:52 2003 +@@ -1,3 +1,4 @@ ++ # $Id: darwin-gc.patch,v 1.1 2003/09/13 04:00:51 megacz Exp $ + .arch ev6 + + .text +diff -urNb boehm-gc/autom4te.cache/output.0 boehm-gc/autom4te.cache/output.0 +--- boehm-gc/autom4te.cache/output.0 Wed Dec 31 16:00:00 1969 ++++ boehm-gc/autom4te.cache/output.0 Mon May 26 13:14:22 2003 +@@ -0,0 +1,5049 @@ ++@%:@! /bin/sh ++@%:@ Guess values for system-dependent variables and create Makefiles. ++@%:@ Generated by GNU Autoconf 2.57. ++@%:@ ++@%:@ Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002 ++@%:@ Free Software Foundation, Inc. ++@%:@ This configure script is free software; the Free Software Foundation ++@%:@ gives unlimited permission to copy, distribute and modify it. ++## --------------------- ## ++## M4sh Initialization. ## ++## --------------------- ## ++ ++# Be Bourne compatible ++if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then ++ emulate sh ++ NULLCMD=: ++ # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which ++ # is contrary to our usage. Disable this feature. ++ alias -g '${1+"$@"}'='"$@"' ++elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then ++ set -o posix ++fi ++ ++# Support unset when possible. ++if (FOO=FOO; unset FOO) >/dev/null 2>&1; then ++ as_unset=unset ++else ++ as_unset=false ++fi ++ ++ ++# Work around bugs in pre-3.0 UWIN ksh. ++$as_unset ENV MAIL MAILPATH ++PS1='$ ' ++PS2='> ' ++PS4='+ ' ++ ++# NLS nuisances. ++for as_var in \ ++ LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \ ++ LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \ ++ LC_TELEPHONE LC_TIME ++do ++ if (set +x; test -n "`(eval $as_var=C; export $as_var) 2>&1`"); then ++ eval $as_var=C; export $as_var ++ else ++ $as_unset $as_var ++ fi ++done ++ ++# Required to use basename. ++if expr a : '\(a\)' >/dev/null 2>&1; then ++ as_expr=expr ++else ++ as_expr=false ++fi ++ ++if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then ++ as_basename=basename ++else ++ as_basename=false ++fi ++ ++ ++# Name of the executable. ++as_me=`$as_basename "$0" || ++$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ ++ X"$0" : 'X\(//\)$' \| \ ++ X"$0" : 'X\(/\)$' \| \ ++ . : '\(.\)' 2>/dev/null || ++echo X/"$0" | ++ sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; } ++ /^X\/\(\/\/\)$/{ s//\1/; q; } ++ /^X\/\(\/\).*/{ s//\1/; q; } ++ s/.*/./; q'` ++ ++ ++# PATH needs CR, and LINENO needs CR and PATH. ++# Avoid depending upon Character Ranges. ++as_cr_letters='abcdefghijklmnopqrstuvwxyz' ++as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' ++as_cr_Letters=$as_cr_letters$as_cr_LETTERS ++as_cr_digits='0123456789' ++as_cr_alnum=$as_cr_Letters$as_cr_digits ++ ++# The user is always right. ++if test "${PATH_SEPARATOR+set}" != set; then ++ echo "#! /bin/sh" >conf$$.sh ++ echo "exit 0" >>conf$$.sh ++ chmod +x conf$$.sh ++ if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then ++ PATH_SEPARATOR=';' ++ else ++ PATH_SEPARATOR=: ++ fi ++ rm -f conf$$.sh ++fi ++ ++ ++ as_lineno_1=$LINENO ++ as_lineno_2=$LINENO ++ as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null` ++ test "x$as_lineno_1" != "x$as_lineno_2" && ++ test "x$as_lineno_3" = "x$as_lineno_2" || { ++ # Find who we are. Look in the path if we contain no path at all ++ # relative or not. ++ case $0 in ++ *[\\/]* ) as_myself=$0 ;; ++ *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break ++done ++ ++ ;; ++ esac ++ # We did not find ourselves, most probably we were run as `sh COMMAND' ++ # in which case we are not to be found in the path. ++ if test "x$as_myself" = x; then ++ as_myself=$0 ++ fi ++ if test ! -f "$as_myself"; then ++ { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2 ++ { (exit 1); exit 1; }; } ++ fi ++ case $CONFIG_SHELL in ++ '') ++ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for as_base in sh bash ksh sh5; do ++ case $as_dir in ++ /*) ++ if ("$as_dir/$as_base" -c ' ++ as_lineno_1=$LINENO ++ as_lineno_2=$LINENO ++ as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null` ++ test "x$as_lineno_1" != "x$as_lineno_2" && ++ test "x$as_lineno_3" = "x$as_lineno_2" ') 2>/dev/null; then ++ $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; } ++ $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; } ++ CONFIG_SHELL=$as_dir/$as_base ++ export CONFIG_SHELL ++ exec "$CONFIG_SHELL" "$0" ${1+"$@"} ++ fi;; ++ esac ++ done ++done ++;; ++ esac ++ ++ # Create $as_me.lineno as a copy of $as_myself, but with $LINENO ++ # uniformly replaced by the line number. The first 'sed' inserts a ++ # line-number line before each line; the second 'sed' does the real ++ # work. The second script uses 'N' to pair each line-number line ++ # with the numbered line, and appends trailing '-' during ++ # substitution so that $LINENO is not a special case at line end. ++ # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the ++ # second 'sed' script. Blame Lee E. McMahon for sed's syntax. :-) ++ sed '=' <$as_myself | ++ sed ' ++ N ++ s,$,-, ++ : loop ++ s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3, ++ t loop ++ s,-$,, ++ s,^['$as_cr_digits']*\n,, ++ ' >$as_me.lineno && ++ chmod +x $as_me.lineno || ++ { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2 ++ { (exit 1); exit 1; }; } ++ ++ # Don't try to exec as it changes $[0], causing all sort of problems ++ # (the dirname of $[0] is not the place where we might find the ++ # original and so on. Autoconf is especially sensible to this). ++ . ./$as_me.lineno ++ # Exit status is that of the last command. ++ exit ++} ++ ++ ++case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in ++ *c*,-n*) ECHO_N= ECHO_C=' ++' ECHO_T=' ' ;; ++ *c*,* ) ECHO_N=-n ECHO_C= ECHO_T= ;; ++ *) ECHO_N= ECHO_C='\c' ECHO_T= ;; ++esac ++ ++if expr a : '\(a\)' >/dev/null 2>&1; then ++ as_expr=expr ++else ++ as_expr=false ++fi ++ ++rm -f conf$$ conf$$.exe conf$$.file ++echo >conf$$.file ++if ln -s conf$$.file conf$$ 2>/dev/null; then ++ # We could just check for DJGPP; but this test a) works b) is more generic ++ # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04). ++ if test -f conf$$.exe; then ++ # Don't use ln at all; we don't have any links ++ as_ln_s='cp -p' ++ else ++ as_ln_s='ln -s' ++ fi ++elif ln conf$$.file conf$$ 2>/dev/null; then ++ as_ln_s=ln ++else ++ as_ln_s='cp -p' ++fi ++rm -f conf$$ conf$$.exe conf$$.file ++ ++if mkdir -p . 2>/dev/null; then ++ as_mkdir_p=: ++else ++ as_mkdir_p=false ++fi ++ ++as_executable_p="test -f" ++ ++# Sed expression to map a string onto a valid CPP name. ++as_tr_cpp="sed y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g" ++ ++# Sed expression to map a string onto a valid variable name. ++as_tr_sh="sed y%*+%pp%;s%[^_$as_cr_alnum]%_%g" ++ ++ ++# IFS ++# We need space, tab and new line, in precisely that order. ++as_nl=' ++' ++IFS=" $as_nl" ++ ++# CDPATH. ++$as_unset CDPATH ++ ++ ++# Name of the host. ++# hostname on some systems (SVR3.2, Linux) returns a bogus exit status, ++# so uname gets run too. ++ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q` ++ ++exec 6>&1 ++ ++# ++# Initializations. ++# ++ac_default_prefix=/usr/local ++ac_config_libobj_dir=. ++cross_compiling=no ++subdirs= ++MFLAGS= ++MAKEFLAGS= ++SHELL=${CONFIG_SHELL-/bin/sh} ++ ++# Maximum number of lines to put in a shell here document. ++# This variable seems obsolete. It should probably be removed, and ++# only ac_max_sed_lines should be used. ++: ${ac_max_here_lines=38} ++ ++# Identity of this package. ++PACKAGE_NAME= ++PACKAGE_TARNAME= ++PACKAGE_VERSION= ++PACKAGE_STRING= ++PACKAGE_BUGREPORT= ++ ++ac_unique_file="gcj_mlc.c" ++ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS gc_basedir build build_cpu build_vendor build_os host host_cpu host_vendor host_os target target_cpu target_vendor target_os mkinstalldirs INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA PACKAGE VERSION ACLOCAL AUTOCONF AUTOMAKE AUTOHEADER MAKEINFO SET_MAKE CC CXX AS ac_ct_AS AR ac_ct_AR RANLIB ac_ct_RANLIB MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT GC_CFLAGS LN_S STRIP ac_ct_STRIP LIBTOOL CXXCPP CPPFLAGS THREADLIBS POWERPC_DARWIN_TRUE POWERPC_DARWIN_FALSE EXTRA_TEST_LIBS target_all INCLUDES CXXINCLUDES addobjs MY_CFLAGS USE_LIBDIR_TRUE USE_LIBDIR_FALSE LIB@&t@OBJS LTLIBOBJS' ++ac_subst_files='' ++ ++# Initialize some variables set by options. ++ac_init_help= ++ac_init_version=false ++# The variables have the same names as the options, with ++# dashes changed to underlines. ++cache_file=/dev/null ++exec_prefix=NONE ++no_create= ++no_recursion= ++prefix=NONE ++program_prefix=NONE ++program_suffix=NONE ++program_transform_name=s,x,x, ++silent= ++site= ++srcdir= ++verbose= ++x_includes=NONE ++x_libraries=NONE ++ ++# Installation directory options. ++# These are left unexpanded so users can "make install exec_prefix=/foo" ++# and all the variables that are supposed to be based on exec_prefix ++# by default will actually change. ++# Use braces instead of parens because sh, perl, etc. also accept them. ++bindir='${exec_prefix}/bin' ++sbindir='${exec_prefix}/sbin' ++libexecdir='${exec_prefix}/libexec' ++datadir='${prefix}/share' ++sysconfdir='${prefix}/etc' ++sharedstatedir='${prefix}/com' ++localstatedir='${prefix}/var' ++libdir='${exec_prefix}/lib' ++includedir='${prefix}/include' ++oldincludedir='/usr/include' ++infodir='${prefix}/info' ++mandir='${prefix}/man' ++ ++ac_prev= ++for ac_option ++do ++ # If the previous option needs an argument, assign it. ++ if test -n "$ac_prev"; then ++ eval "$ac_prev=\$ac_option" ++ ac_prev= ++ continue ++ fi ++ ++ ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'` ++ ++ # Accept the important Cygnus configure options, so we can diagnose typos. ++ ++ case $ac_option in ++ ++ -bindir | --bindir | --bindi | --bind | --bin | --bi) ++ ac_prev=bindir ;; ++ -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*) ++ bindir=$ac_optarg ;; ++ ++ -build | --build | --buil | --bui | --bu) ++ ac_prev=build_alias ;; ++ -build=* | --build=* | --buil=* | --bui=* | --bu=*) ++ build_alias=$ac_optarg ;; ++ ++ -cache-file | --cache-file | --cache-fil | --cache-fi \ ++ | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c) ++ ac_prev=cache_file ;; ++ -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ ++ | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*) ++ cache_file=$ac_optarg ;; ++ ++ --config-cache | -C) ++ cache_file=config.cache ;; ++ ++ -datadir | --datadir | --datadi | --datad | --data | --dat | --da) ++ ac_prev=datadir ;; ++ -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \ ++ | --da=*) ++ datadir=$ac_optarg ;; ++ ++ -disable-* | --disable-*) ++ ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'` ++ # Reject names that are not valid shell variable names. ++ expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null && ++ { echo "$as_me: error: invalid feature name: $ac_feature" >&2 ++ { (exit 1); exit 1; }; } ++ ac_feature=`echo $ac_feature | sed 's/-/_/g'` ++ eval "enable_$ac_feature=no" ;; ++ ++ -enable-* | --enable-*) ++ ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'` ++ # Reject names that are not valid shell variable names. ++ expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null && ++ { echo "$as_me: error: invalid feature name: $ac_feature" >&2 ++ { (exit 1); exit 1; }; } ++ ac_feature=`echo $ac_feature | sed 's/-/_/g'` ++ case $ac_option in ++ *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;; ++ *) ac_optarg=yes ;; ++ esac ++ eval "enable_$ac_feature='$ac_optarg'" ;; ++ ++ -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ ++ | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ ++ | --exec | --exe | --ex) ++ ac_prev=exec_prefix ;; ++ -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \ ++ | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \ ++ | --exec=* | --exe=* | --ex=*) ++ exec_prefix=$ac_optarg ;; ++ ++ -gas | --gas | --ga | --g) ++ # Obsolete; use --with-gas. ++ with_gas=yes ;; ++ ++ -help | --help | --hel | --he | -h) ++ ac_init_help=long ;; ++ -help=r* | --help=r* | --hel=r* | --he=r* | -hr*) ++ ac_init_help=recursive ;; ++ -help=s* | --help=s* | --hel=s* | --he=s* | -hs*) ++ ac_init_help=short ;; ++ ++ -host | --host | --hos | --ho) ++ ac_prev=host_alias ;; ++ -host=* | --host=* | --hos=* | --ho=*) ++ host_alias=$ac_optarg ;; ++ ++ -includedir | --includedir | --includedi | --included | --include \ ++ | --includ | --inclu | --incl | --inc) ++ ac_prev=includedir ;; ++ -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \ ++ | --includ=* | --inclu=* | --incl=* | --inc=*) ++ includedir=$ac_optarg ;; ++ ++ -infodir | --infodir | --infodi | --infod | --info | --inf) ++ ac_prev=infodir ;; ++ -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*) ++ infodir=$ac_optarg ;; ++ ++ -libdir | --libdir | --libdi | --libd) ++ ac_prev=libdir ;; ++ -libdir=* | --libdir=* | --libdi=* | --libd=*) ++ libdir=$ac_optarg ;; ++ ++ -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \ ++ | --libexe | --libex | --libe) ++ ac_prev=libexecdir ;; ++ -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \ ++ | --libexe=* | --libex=* | --libe=*) ++ libexecdir=$ac_optarg ;; ++ ++ -localstatedir | --localstatedir | --localstatedi | --localstated \ ++ | --localstate | --localstat | --localsta | --localst \ ++ | --locals | --local | --loca | --loc | --lo) ++ ac_prev=localstatedir ;; ++ -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \ ++ | --localstate=* | --localstat=* | --localsta=* | --localst=* \ ++ | --locals=* | --local=* | --loca=* | --loc=* | --lo=*) ++ localstatedir=$ac_optarg ;; ++ ++ -mandir | --mandir | --mandi | --mand | --man | --ma | --m) ++ ac_prev=mandir ;; ++ -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*) ++ mandir=$ac_optarg ;; ++ ++ -nfp | --nfp | --nf) ++ # Obsolete; use --without-fp. ++ with_fp=no ;; ++ ++ -no-create | --no-create | --no-creat | --no-crea | --no-cre \ ++ | --no-cr | --no-c | -n) ++ no_create=yes ;; ++ ++ -no-recursion | --no-recursion | --no-recursio | --no-recursi \ ++ | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) ++ no_recursion=yes ;; ++ ++ -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \ ++ | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \ ++ | --oldin | --oldi | --old | --ol | --o) ++ ac_prev=oldincludedir ;; ++ -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \ ++ | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \ ++ | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*) ++ oldincludedir=$ac_optarg ;; ++ ++ -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) ++ ac_prev=prefix ;; ++ -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) ++ prefix=$ac_optarg ;; ++ ++ -program-prefix | --program-prefix | --program-prefi | --program-pref \ ++ | --program-pre | --program-pr | --program-p) ++ ac_prev=program_prefix ;; ++ -program-prefix=* | --program-prefix=* | --program-prefi=* \ ++ | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*) ++ program_prefix=$ac_optarg ;; ++ ++ -program-suffix | --program-suffix | --program-suffi | --program-suff \ ++ | --program-suf | --program-su | --program-s) ++ ac_prev=program_suffix ;; ++ -program-suffix=* | --program-suffix=* | --program-suffi=* \ ++ | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*) ++ program_suffix=$ac_optarg ;; ++ ++ -program-transform-name | --program-transform-name \ ++ | --program-transform-nam | --program-transform-na \ ++ | --program-transform-n | --program-transform- \ ++ | --program-transform | --program-transfor \ ++ | --program-transfo | --program-transf \ ++ | --program-trans | --program-tran \ ++ | --progr-tra | --program-tr | --program-t) ++ ac_prev=program_transform_name ;; ++ -program-transform-name=* | --program-transform-name=* \ ++ | --program-transform-nam=* | --program-transform-na=* \ ++ | --program-transform-n=* | --program-transform-=* \ ++ | --program-transform=* | --program-transfor=* \ ++ | --program-transfo=* | --program-transf=* \ ++ | --program-trans=* | --program-tran=* \ ++ | --progr-tra=* | --program-tr=* | --program-t=*) ++ program_transform_name=$ac_optarg ;; ++ ++ -q | -quiet | --quiet | --quie | --qui | --qu | --q \ ++ | -silent | --silent | --silen | --sile | --sil) ++ silent=yes ;; ++ ++ -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb) ++ ac_prev=sbindir ;; ++ -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \ ++ | --sbi=* | --sb=*) ++ sbindir=$ac_optarg ;; ++ ++ -sharedstatedir | --sharedstatedir | --sharedstatedi \ ++ | --sharedstated | --sharedstate | --sharedstat | --sharedsta \ ++ | --sharedst | --shareds | --shared | --share | --shar \ ++ | --sha | --sh) ++ ac_prev=sharedstatedir ;; ++ -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \ ++ | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \ ++ | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \ ++ | --sha=* | --sh=*) ++ sharedstatedir=$ac_optarg ;; ++ ++ -site | --site | --sit) ++ ac_prev=site ;; ++ -site=* | --site=* | --sit=*) ++ site=$ac_optarg ;; ++ ++ -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) ++ ac_prev=srcdir ;; ++ -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) ++ srcdir=$ac_optarg ;; ++ ++ -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \ ++ | --syscon | --sysco | --sysc | --sys | --sy) ++ ac_prev=sysconfdir ;; ++ -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \ ++ | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*) ++ sysconfdir=$ac_optarg ;; ++ ++ -target | --target | --targe | --targ | --tar | --ta | --t) ++ ac_prev=target_alias ;; ++ -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) ++ target_alias=$ac_optarg ;; ++ ++ -v | -verbose | --verbose | --verbos | --verbo | --verb) ++ verbose=yes ;; ++ ++ -version | --version | --versio | --versi | --vers | -V) ++ ac_init_version=: ;; ++ ++ -with-* | --with-*) ++ ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'` ++ # Reject names that are not valid shell variable names. ++ expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null && ++ { echo "$as_me: error: invalid package name: $ac_package" >&2 ++ { (exit 1); exit 1; }; } ++ ac_package=`echo $ac_package| sed 's/-/_/g'` ++ case $ac_option in ++ *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;; ++ *) ac_optarg=yes ;; ++ esac ++ eval "with_$ac_package='$ac_optarg'" ;; ++ ++ -without-* | --without-*) ++ ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'` ++ # Reject names that are not valid shell variable names. ++ expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null && ++ { echo "$as_me: error: invalid package name: $ac_package" >&2 ++ { (exit 1); exit 1; }; } ++ ac_package=`echo $ac_package | sed 's/-/_/g'` ++ eval "with_$ac_package=no" ;; ++ ++ --x) ++ # Obsolete; use --with-x. ++ with_x=yes ;; ++ ++ -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \ ++ | --x-incl | --x-inc | --x-in | --x-i) ++ ac_prev=x_includes ;; ++ -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \ ++ | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*) ++ x_includes=$ac_optarg ;; ++ ++ -x-libraries | --x-libraries | --x-librarie | --x-librari \ ++ | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l) ++ ac_prev=x_libraries ;; ++ -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \ ++ | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) ++ x_libraries=$ac_optarg ;; ++ ++ -*) { echo "$as_me: error: unrecognized option: $ac_option ++Try \`$0 --help' for more information." >&2 ++ { (exit 1); exit 1; }; } ++ ;; ++ ++ *=*) ++ ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='` ++ # Reject names that are not valid shell variable names. ++ expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null && ++ { echo "$as_me: error: invalid variable name: $ac_envvar" >&2 ++ { (exit 1); exit 1; }; } ++ ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ++ eval "$ac_envvar='$ac_optarg'" ++ export $ac_envvar ;; ++ ++ *) ++ # FIXME: should be removed in autoconf 3.0. ++ echo "$as_me: WARNING: you should use --build, --host, --target" >&2 ++ expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null && ++ echo "$as_me: WARNING: invalid host type: $ac_option" >&2 ++ : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option} ++ ;; ++ ++ esac ++done ++ ++if test -n "$ac_prev"; then ++ ac_option=--`echo $ac_prev | sed 's/_/-/g'` ++ { echo "$as_me: error: missing argument to $ac_option" >&2 ++ { (exit 1); exit 1; }; } ++fi ++ ++# Be sure to have absolute paths. ++for ac_var in exec_prefix prefix ++do ++ eval ac_val=$`echo $ac_var` ++ case $ac_val in ++ [\\/$]* | ?:[\\/]* | NONE | '' ) ;; ++ *) { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2 ++ { (exit 1); exit 1; }; };; ++ esac ++done ++ ++# Be sure to have absolute paths. ++for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \ ++ localstatedir libdir includedir oldincludedir infodir mandir ++do ++ eval ac_val=$`echo $ac_var` ++ case $ac_val in ++ [\\/$]* | ?:[\\/]* ) ;; ++ *) { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2 ++ { (exit 1); exit 1; }; };; ++ esac ++done ++ ++# There might be people who depend on the old broken behavior: `$host' ++# used to hold the argument of --host etc. ++# FIXME: To remove some day. ++build=$build_alias ++host=$host_alias ++target=$target_alias ++ ++# FIXME: To remove some day. ++if test "x$host_alias" != x; then ++ if test "x$build_alias" = x; then ++ cross_compiling=maybe ++ echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host. ++ If a cross compiler is detected then cross compile mode will be used." >&2 ++ elif test "x$build_alias" != "x$host_alias"; then ++ cross_compiling=yes ++ fi ++fi ++ ++ac_tool_prefix= ++test -n "$host_alias" && ac_tool_prefix=$host_alias- ++ ++test "$silent" = yes && exec 6>/dev/null ++ ++ ++# Find the source files, if location was not specified. ++if test -z "$srcdir"; then ++ ac_srcdir_defaulted=yes ++ # Try the directory containing this script, then its parent. ++ ac_confdir=`(dirname "$0") 2>/dev/null || ++$as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ ++ X"$0" : 'X\(//\)[^/]' \| \ ++ X"$0" : 'X\(//\)$' \| \ ++ X"$0" : 'X\(/\)' \| \ ++ . : '\(.\)' 2>/dev/null || ++echo X"$0" | ++ sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; } ++ /^X\(\/\/\)[^/].*/{ s//\1/; q; } ++ /^X\(\/\/\)$/{ s//\1/; q; } ++ /^X\(\/\).*/{ s//\1/; q; } ++ s/.*/./; q'` ++ srcdir=$ac_confdir ++ if test ! -r $srcdir/$ac_unique_file; then ++ srcdir=.. ++ fi ++else ++ ac_srcdir_defaulted=no ++fi ++if test ! -r $srcdir/$ac_unique_file; then ++ if test "$ac_srcdir_defaulted" = yes; then ++ { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2 ++ { (exit 1); exit 1; }; } ++ else ++ { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2 ++ { (exit 1); exit 1; }; } ++ fi ++fi ++(cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null || ++ { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2 ++ { (exit 1); exit 1; }; } ++srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'` ++ac_env_build_alias_set=${build_alias+set} ++ac_env_build_alias_value=$build_alias ++ac_cv_env_build_alias_set=${build_alias+set} ++ac_cv_env_build_alias_value=$build_alias ++ac_env_host_alias_set=${host_alias+set} ++ac_env_host_alias_value=$host_alias ++ac_cv_env_host_alias_set=${host_alias+set} ++ac_cv_env_host_alias_value=$host_alias ++ac_env_target_alias_set=${target_alias+set} ++ac_env_target_alias_value=$target_alias ++ac_cv_env_target_alias_set=${target_alias+set} ++ac_cv_env_target_alias_value=$target_alias ++ac_env_CXXCPP_set=${CXXCPP+set} ++ac_env_CXXCPP_value=$CXXCPP ++ac_cv_env_CXXCPP_set=${CXXCPP+set} ++ac_cv_env_CXXCPP_value=$CXXCPP ++ac_env_CPPFLAGS_set=${CPPFLAGS+set} ++ac_env_CPPFLAGS_value=$CPPFLAGS ++ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set} ++ac_cv_env_CPPFLAGS_value=$CPPFLAGS ++ ++# ++# Report the --help message. ++# ++if test "$ac_init_help" = "long"; then ++ # Omit some internal or obsolete options to make the list less imposing. ++ # This message is too long to be a string in the A/UX 3.1 sh. ++ cat <<_ACEOF ++\`configure' configures this package to adapt to many kinds of systems. ++ ++Usage: $0 [OPTION]... [VAR=VALUE]... ++ ++To assign environment variables (e.g., CC, CFLAGS...), specify them as ++VAR=VALUE. See below for descriptions of some of the useful variables. ++ ++Defaults for the options are specified in brackets. ++ ++Configuration: ++ -h, --help display this help and exit ++ --help=short display options specific to this package ++ --help=recursive display the short help of all the included packages ++ -V, --version display version information and exit ++ -q, --quiet, --silent do not print \`checking...' messages ++ --cache-file=FILE cache test results in FILE [disabled] ++ -C, --config-cache alias for \`--cache-file=config.cache' ++ -n, --no-create do not create output files ++ --srcdir=DIR find the sources in DIR [configure dir or \`..'] ++ ++_ACEOF ++ ++ cat <<_ACEOF ++Installation directories: ++ --prefix=PREFIX install architecture-independent files in PREFIX ++ [$ac_default_prefix] ++ --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX ++ [PREFIX] ++ ++By default, \`make install' will install all the files in ++\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify ++an installation prefix other than \`$ac_default_prefix' using \`--prefix', ++for instance \`--prefix=\$HOME'. ++ ++For better control, use the options below. ++ ++Fine tuning of the installation directories: ++ --bindir=DIR user executables [EPREFIX/bin] ++ --sbindir=DIR system admin executables [EPREFIX/sbin] ++ --libexecdir=DIR program executables [EPREFIX/libexec] ++ --datadir=DIR read-only architecture-independent data [PREFIX/share] ++ --sysconfdir=DIR read-only single-machine data [PREFIX/etc] ++ --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com] ++ --localstatedir=DIR modifiable single-machine data [PREFIX/var] ++ --libdir=DIR object code libraries [EPREFIX/lib] ++ --includedir=DIR C header files [PREFIX/include] ++ --oldincludedir=DIR C header files for non-gcc [/usr/include] ++ --infodir=DIR info documentation [PREFIX/info] ++ --mandir=DIR man documentation [PREFIX/man] ++_ACEOF ++ ++ cat <<\_ACEOF ++ ++Program names: ++ --program-prefix=PREFIX prepend PREFIX to installed program names ++ --program-suffix=SUFFIX append SUFFIX to installed program names ++ --program-transform-name=PROGRAM run sed PROGRAM on installed program names ++ ++System types: ++ --build=BUILD configure for building on BUILD [guessed] ++ --host=HOST cross-compile to build programs to run on HOST [BUILD] ++ --target=TARGET configure for building compilers for TARGET [HOST] ++_ACEOF ++fi ++ ++if test -n "$ac_init_help"; then ++ ++ cat <<\_ACEOF ++ ++Optional Features: ++ --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no) ++ --enable-FEATURE[=ARG] include FEATURE [ARG=yes] ++ --enable-multilib build many library versions (default) ++ --enable-maintainer-mode enable make rules and dependencies not useful ++ (and sometimes confusing) to the casual installer ++ --enable-shared=PKGS build shared libraries default=yes ++ --enable-static=PKGS build static libraries default=yes ++ --enable-fast-install=PKGS optimize for fast installation default=yes ++ --disable-libtool-lock avoid locking (might break parallel builds) ++ --enable-parallel-mark parallelize marking and free list construction ++ --enable-shared=PKGS build shared libraries default=no ++ --enable-full-debug include full support for pointer backtracing etc. ++ ++Optional Packages: ++ --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] ++ --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) ++ --with-gnu-ld assume the C compiler uses GNU ld default=no ++ --with-pic try to use only PIC/non-PIC objects default=use both ++ --with-target-subdir=SUBDIR ++ configuring with a cross compiler ++ --with-cross-host=HOST configuring with a cross compiler ++ --with-ecos enable runtime eCos target support ++ ++Some influential environment variables: ++ CXXCPP C++ preprocessor ++ CPPFLAGS C/C++ preprocessor flags, e.g. -I if you have ++ headers in a nonstandard directory ++ ++Use these variables to override the choices made by `configure' or to help ++it to find libraries and programs with nonstandard names/locations. ++ ++_ACEOF ++fi ++ ++if test "$ac_init_help" = "recursive"; then ++ # If there are subdirs, report their specific --help. ++ ac_popdir=`pwd` ++ for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue ++ test -d $ac_dir || continue ++ ac_builddir=. ++ ++if test "$ac_dir" != .; then ++ ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'` ++ # A "../" for each directory in $ac_dir_suffix. ++ ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'` ++else ++ ac_dir_suffix= ac_top_builddir= ++fi ++ ++case $srcdir in ++ .) # No --srcdir option. We are building in place. ++ ac_srcdir=. ++ if test -z "$ac_top_builddir"; then ++ ac_top_srcdir=. ++ else ++ ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'` ++ fi ;; ++ [\\/]* | ?:[\\/]* ) # Absolute path. ++ ac_srcdir=$srcdir$ac_dir_suffix; ++ ac_top_srcdir=$srcdir ;; ++ *) # Relative path. ++ ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix ++ ac_top_srcdir=$ac_top_builddir$srcdir ;; ++esac ++# Don't blindly perform a `cd "$ac_dir"/$ac_foo && pwd` since $ac_foo can be ++# absolute. ++ac_abs_builddir=`cd "$ac_dir" && cd $ac_builddir && pwd` ++ac_abs_top_builddir=`cd "$ac_dir" && cd ${ac_top_builddir}. && pwd` ++ac_abs_srcdir=`cd "$ac_dir" && cd $ac_srcdir && pwd` ++ac_abs_top_srcdir=`cd "$ac_dir" && cd $ac_top_srcdir && pwd` ++ ++ cd $ac_dir ++ # Check for guested configure; otherwise get Cygnus style configure. ++ if test -f $ac_srcdir/configure.gnu; then ++ echo ++ $SHELL $ac_srcdir/configure.gnu --help=recursive ++ elif test -f $ac_srcdir/configure; then ++ echo ++ $SHELL $ac_srcdir/configure --help=recursive ++ elif test -f $ac_srcdir/configure.ac || ++ test -f $ac_srcdir/configure.in; then ++ echo ++ $ac_configure --help ++ else ++ echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2 ++ fi ++ cd $ac_popdir ++ done ++fi ++ ++test -n "$ac_init_help" && exit 0 ++if $ac_init_version; then ++ cat <<\_ACEOF ++ ++Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002 ++Free Software Foundation, Inc. ++This configure script is free software; the Free Software Foundation ++gives unlimited permission to copy, distribute and modify it. ++_ACEOF ++ exit 0 ++fi ++exec 5>config.log ++cat >&5 <<_ACEOF ++This file contains any messages produced by compilers while ++running configure, to aid debugging if configure makes a mistake. ++ ++It was created by $as_me, which was ++generated by GNU Autoconf 2.57. Invocation command line was ++ ++ $ $0 $@ ++ ++_ACEOF ++{ ++cat <<_ASUNAME ++@%:@@%:@ --------- @%:@@%:@ ++@%:@@%:@ Platform. @%:@@%:@ ++@%:@@%:@ --------- @%:@@%:@ ++ ++hostname = `(hostname || uname -n) 2>/dev/null | sed 1q` ++uname -m = `(uname -m) 2>/dev/null || echo unknown` ++uname -r = `(uname -r) 2>/dev/null || echo unknown` ++uname -s = `(uname -s) 2>/dev/null || echo unknown` ++uname -v = `(uname -v) 2>/dev/null || echo unknown` ++ ++/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown` ++/bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown` ++ ++/bin/arch = `(/bin/arch) 2>/dev/null || echo unknown` ++/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown` ++/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown` ++hostinfo = `(hostinfo) 2>/dev/null || echo unknown` ++/bin/machine = `(/bin/machine) 2>/dev/null || echo unknown` ++/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown` ++/bin/universe = `(/bin/universe) 2>/dev/null || echo unknown` ++ ++_ASUNAME ++ ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ echo "PATH: $as_dir" ++done ++ ++} >&5 ++ ++cat >&5 <<_ACEOF ++ ++ ++@%:@@%:@ ----------- @%:@@%:@ ++@%:@@%:@ Core tests. @%:@@%:@ ++@%:@@%:@ ----------- @%:@@%:@ ++ ++_ACEOF ++ ++ ++# Keep a trace of the command line. ++# Strip out --no-create and --no-recursion so they do not pile up. ++# Strip out --silent because we don't want to record it for future runs. ++# Also quote any args containing shell meta-characters. ++# Make two passes to allow for proper duplicate-argument suppression. ++ac_configure_args= ++ac_configure_args0= ++ac_configure_args1= ++ac_sep= ++ac_must_keep_next=false ++for ac_pass in 1 2 ++do ++ for ac_arg ++ do ++ case $ac_arg in ++ -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;; ++ -q | -quiet | --quiet | --quie | --qui | --qu | --q \ ++ | -silent | --silent | --silen | --sile | --sil) ++ continue ;; ++ *" "*|*" "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*) ++ ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; ++ esac ++ case $ac_pass in ++ 1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;; ++ 2) ++ ac_configure_args1="$ac_configure_args1 '$ac_arg'" ++ if test $ac_must_keep_next = true; then ++ ac_must_keep_next=false # Got value, back to normal. ++ else ++ case $ac_arg in ++ *=* | --config-cache | -C | -disable-* | --disable-* \ ++ | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \ ++ | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \ ++ | -with-* | --with-* | -without-* | --without-* | --x) ++ case "$ac_configure_args0 " in ++ "$ac_configure_args1"*" '$ac_arg' "* ) continue ;; ++ esac ++ ;; ++ -* ) ac_must_keep_next=true ;; ++ esac ++ fi ++ ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'" ++ # Get rid of the leading space. ++ ac_sep=" " ++ ;; ++ esac ++ done ++done ++$as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; } ++$as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; } ++ ++# When interrupted or exit'd, cleanup temporary files, and complete ++# config.log. We remove comments because anyway the quotes in there ++# would cause problems or look ugly. ++# WARNING: Be sure not to use single quotes in there, as some shells, ++# such as our DU 5.0 friend, will then `close' the trap. ++trap 'exit_status=$? ++ # Save into config.log some information that might help in debugging. ++ { ++ echo ++ ++ cat <<\_ASBOX ++@%:@@%:@ ---------------- @%:@@%:@ ++@%:@@%:@ Cache variables. @%:@@%:@ ++@%:@@%:@ ---------------- @%:@@%:@ ++_ASBOX ++ echo ++ # The following way of writing the cache mishandles newlines in values, ++{ ++ (set) 2>&1 | ++ case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in ++ *ac_space=\ *) ++ sed -n \ ++ "s/'"'"'/'"'"'\\\\'"'"''"'"'/g; ++ s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p" ++ ;; ++ *) ++ sed -n \ ++ "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p" ++ ;; ++ esac; ++} ++ echo ++ ++ cat <<\_ASBOX ++@%:@@%:@ ----------------- @%:@@%:@ ++@%:@@%:@ Output variables. @%:@@%:@ ++@%:@@%:@ ----------------- @%:@@%:@ ++_ASBOX ++ echo ++ for ac_var in $ac_subst_vars ++ do ++ eval ac_val=$`echo $ac_var` ++ echo "$ac_var='"'"'$ac_val'"'"'" ++ done | sort ++ echo ++ ++ if test -n "$ac_subst_files"; then ++ cat <<\_ASBOX ++@%:@@%:@ ------------- @%:@@%:@ ++@%:@@%:@ Output files. @%:@@%:@ ++@%:@@%:@ ------------- @%:@@%:@ ++_ASBOX ++ echo ++ for ac_var in $ac_subst_files ++ do ++ eval ac_val=$`echo $ac_var` ++ echo "$ac_var='"'"'$ac_val'"'"'" ++ done | sort ++ echo ++ fi ++ ++ if test -s confdefs.h; then ++ cat <<\_ASBOX ++@%:@@%:@ ----------- @%:@@%:@ ++@%:@@%:@ confdefs.h. @%:@@%:@ ++@%:@@%:@ ----------- @%:@@%:@ ++_ASBOX ++ echo ++ sed "/^$/d" confdefs.h | sort ++ echo ++ fi ++ test "$ac_signal" != 0 && ++ echo "$as_me: caught signal $ac_signal" ++ echo "$as_me: exit $exit_status" ++ } >&5 ++ rm -f core core.* *.core && ++ rm -rf conftest* confdefs* conf$$* $ac_clean_files && ++ exit $exit_status ++ ' 0 ++for ac_signal in 1 2 13 15; do ++ trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal ++done ++ac_signal=0 ++ ++# confdefs.h avoids OS command line length limits that DEFS can exceed. ++rm -rf conftest* confdefs.h ++# AIX cpp loses on an empty file, so make sure it contains at least a newline. ++echo >confdefs.h ++ ++# Predefined preprocessor variables. ++ ++cat >>confdefs.h <<_ACEOF ++@%:@define PACKAGE_NAME "$PACKAGE_NAME" ++_ACEOF ++ ++ ++cat >>confdefs.h <<_ACEOF ++@%:@define PACKAGE_TARNAME "$PACKAGE_TARNAME" ++_ACEOF ++ ++ ++cat >>confdefs.h <<_ACEOF ++@%:@define PACKAGE_VERSION "$PACKAGE_VERSION" ++_ACEOF ++ ++ ++cat >>confdefs.h <<_ACEOF ++@%:@define PACKAGE_STRING "$PACKAGE_STRING" ++_ACEOF ++ ++ ++cat >>confdefs.h <<_ACEOF ++@%:@define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT" ++_ACEOF ++ ++ ++# Let the site file select an alternate cache file if it wants to. ++# Prefer explicitly selected file to automatically selected ones. ++if test -z "$CONFIG_SITE"; then ++ if test "x$prefix" != xNONE; then ++ CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site" ++ else ++ CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site" ++ fi ++fi ++for ac_site_file in $CONFIG_SITE; do ++ if test -r "$ac_site_file"; then ++ { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5 ++echo "$as_me: loading site script $ac_site_file" >&6;} ++ sed 's/^/| /' "$ac_site_file" >&5 ++ . "$ac_site_file" ++ fi ++done ++ ++if test -r "$cache_file"; then ++ # Some versions of bash will fail to source /dev/null (special ++ # files actually), so we avoid doing that. ++ if test -f "$cache_file"; then ++ { echo "$as_me:$LINENO: loading cache $cache_file" >&5 ++echo "$as_me: loading cache $cache_file" >&6;} ++ case $cache_file in ++ [\\/]* | ?:[\\/]* ) . $cache_file;; ++ *) . ./$cache_file;; ++ esac ++ fi ++else ++ { echo "$as_me:$LINENO: creating cache $cache_file" >&5 ++echo "$as_me: creating cache $cache_file" >&6;} ++ >$cache_file ++fi ++ ++# Check that the precious variables saved in the cache have kept the same ++# value. ++ac_cache_corrupted=false ++for ac_var in `(set) 2>&1 | ++ sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do ++ eval ac_old_set=\$ac_cv_env_${ac_var}_set ++ eval ac_new_set=\$ac_env_${ac_var}_set ++ eval ac_old_val="\$ac_cv_env_${ac_var}_value" ++ eval ac_new_val="\$ac_env_${ac_var}_value" ++ case $ac_old_set,$ac_new_set in ++ set,) ++ { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5 ++echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;} ++ ac_cache_corrupted=: ;; ++ ,set) ++ { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5 ++echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;} ++ ac_cache_corrupted=: ;; ++ ,);; ++ *) ++ if test "x$ac_old_val" != "x$ac_new_val"; then ++ { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5 ++echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;} ++ { echo "$as_me:$LINENO: former value: $ac_old_val" >&5 ++echo "$as_me: former value: $ac_old_val" >&2;} ++ { echo "$as_me:$LINENO: current value: $ac_new_val" >&5 ++echo "$as_me: current value: $ac_new_val" >&2;} ++ ac_cache_corrupted=: ++ fi;; ++ esac ++ # Pass precious variables to config.status. ++ if test "$ac_new_set" = set; then ++ case $ac_new_val in ++ *" "*|*" "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*) ++ ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; ++ *) ac_arg=$ac_var=$ac_new_val ;; ++ esac ++ case " $ac_configure_args " in ++ *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy. ++ *) ac_configure_args="$ac_configure_args '$ac_arg'" ;; ++ esac ++ fi ++done ++if $ac_cache_corrupted; then ++ { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5 ++echo "$as_me: error: changes in the environment can compromise the build" >&2;} ++ { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5 ++echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;} ++ { (exit 1); exit 1; }; } ++fi ++ ++ac_ext=c ++ac_cpp='$CPP $CPPFLAGS' ++ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ++ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ++ac_compiler_gnu=$ac_cv_c_compiler_gnu ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++# This works around the fact that libtool configuration may change LD ++# for this particular configuration, but some shells, instead of ++# keeping the changes in LD private, export them just because LD is ++# exported. ++ORIGINAL_LD_FOR_MULTILIBS=$LD ++ ++ac_aux_dir= ++for ac_dir in . $srcdir/.; do ++ if test -f $ac_dir/install-sh; then ++ ac_aux_dir=$ac_dir ++ ac_install_sh="$ac_aux_dir/install-sh -c" ++ break ++ elif test -f $ac_dir/install.sh; then ++ ac_aux_dir=$ac_dir ++ ac_install_sh="$ac_aux_dir/install.sh -c" ++ break ++ elif test -f $ac_dir/shtool; then ++ ac_aux_dir=$ac_dir ++ ac_install_sh="$ac_aux_dir/shtool install -c" ++ break ++ fi ++done ++if test -z "$ac_aux_dir"; then ++ { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in . $srcdir/." >&5 ++echo "$as_me: error: cannot find install-sh or install.sh in . $srcdir/." >&2;} ++ { (exit 1); exit 1; }; } ++fi ++ac_config_guess="$SHELL $ac_aux_dir/config.guess" ++ac_config_sub="$SHELL $ac_aux_dir/config.sub" ++ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure. ++ ++ ++# Make sure we can run config.sub. ++$ac_config_sub sun4 >/dev/null 2>&1 || ++ { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5 ++echo "$as_me: error: cannot run $ac_config_sub" >&2;} ++ { (exit 1); exit 1; }; } ++ ++echo "$as_me:$LINENO: checking build system type" >&5 ++echo $ECHO_N "checking build system type... $ECHO_C" >&6 ++if test "${ac_cv_build+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ ac_cv_build_alias=$build_alias ++test -z "$ac_cv_build_alias" && ++ ac_cv_build_alias=`$ac_config_guess` ++test -z "$ac_cv_build_alias" && ++ { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5 ++echo "$as_me: error: cannot guess build type; you must specify one" >&2;} ++ { (exit 1); exit 1; }; } ++ac_cv_build=`$ac_config_sub $ac_cv_build_alias` || ++ { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5 ++echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;} ++ { (exit 1); exit 1; }; } ++ ++fi ++echo "$as_me:$LINENO: result: $ac_cv_build" >&5 ++echo "${ECHO_T}$ac_cv_build" >&6 ++build=$ac_cv_build ++build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'` ++build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'` ++build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'` ++ ++ ++echo "$as_me:$LINENO: checking host system type" >&5 ++echo $ECHO_N "checking host system type... $ECHO_C" >&6 ++if test "${ac_cv_host+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ ac_cv_host_alias=$host_alias ++test -z "$ac_cv_host_alias" && ++ ac_cv_host_alias=$ac_cv_build_alias ++ac_cv_host=`$ac_config_sub $ac_cv_host_alias` || ++ { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5 ++echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;} ++ { (exit 1); exit 1; }; } ++ ++fi ++echo "$as_me:$LINENO: result: $ac_cv_host" >&5 ++echo "${ECHO_T}$ac_cv_host" >&6 ++host=$ac_cv_host ++host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'` ++host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'` ++host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'` ++ ++ ++# Find a good install program. We prefer a C program (faster), ++# so one script is as good as another. But avoid the broken or ++# incompatible versions: ++# SysV /etc/install, /usr/sbin/install ++# SunOS /usr/etc/install ++# IRIX /sbin/install ++# AIX /bin/install ++# AmigaOS /C/install, which installs bootblocks on floppy discs ++# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag ++# AFS /usr/afsws/bin/install, which mishandles nonexistent args ++# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff" ++# ./install, which can be erroneously created by make from ./install.sh. ++echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5 ++echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6 ++if test -z "$INSTALL"; then ++if test "${ac_cv_path_install+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ # Account for people who put trailing slashes in PATH elements. ++case $as_dir/ in ++ ./ | .// | /cC/* | \ ++ /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \ ++ /usr/ucb/* ) ;; ++ *) ++ # OSF1 and SCO ODT 3.0 have their own names for install. ++ # Don't use installbsd from OSF since it installs stuff as root ++ # by default. ++ for ac_prog in ginstall scoinst install; do ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then ++ if test $ac_prog = install && ++ grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then ++ # AIX install. It has an incompatible calling convention. ++ : ++ elif test $ac_prog = install && ++ grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then ++ # program-specific install script used by HP pwplus--don't use. ++ : ++ else ++ ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c" ++ break 3 ++ fi ++ fi ++ done ++ done ++ ;; ++esac ++done ++ ++ ++fi ++ if test "${ac_cv_path_install+set}" = set; then ++ INSTALL=$ac_cv_path_install ++ else ++ # As a last resort, use the slow shell script. We don't cache a ++ # path for INSTALL within a source directory, because that will ++ # break other packages using the cache if that directory is ++ # removed, or if the path is relative. ++ INSTALL=$ac_install_sh ++ fi ++fi ++echo "$as_me:$LINENO: result: $INSTALL" >&5 ++echo "${ECHO_T}$INSTALL" >&6 ++ ++# Use test -z because SunOS4 sh mishandles braces in ${var-val}. ++# It thinks the first close brace ends the variable substitution. ++test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}' ++ ++test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}' ++ ++test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644' ++ ++echo "$as_me:$LINENO: checking whether build environment is sane" >&5 ++echo $ECHO_N "checking whether build environment is sane... $ECHO_C" >&6 ++# Just in case ++sleep 1 ++echo timestamp > conftestfile ++# Do `set' in a subshell so we don't clobber the current shell's ++# arguments. Must try -L first in case configure is actually a ++# symlink; some systems play weird games with the mod time of symlinks ++# (eg FreeBSD returns the mod time of the symlink's containing ++# directory). ++if ( ++ set X `ls -Lt $srcdir/configure conftestfile 2> /dev/null` ++ if test "$*" = "X"; then ++ # -L didn't work. ++ set X `ls -t $srcdir/configure conftestfile` ++ fi ++ if test "$*" != "X $srcdir/configure conftestfile" \ ++ && test "$*" != "X conftestfile $srcdir/configure"; then ++ ++ # If neither matched, then we have a broken ls. This can happen ++ # if, for instance, CONFIG_SHELL is bash and it inherits a ++ # broken ls alias from the environment. This has actually ++ # happened. Such a system could not be considered "sane". ++ { { echo "$as_me:$LINENO: error: ls -t appears to fail. Make sure there is not a broken ++alias in your environment" >&5 ++echo "$as_me: error: ls -t appears to fail. Make sure there is not a broken ++alias in your environment" >&2;} ++ { (exit 1); exit 1; }; } ++ fi ++ ++ test "$2" = conftestfile ++ ) ++then ++ # Ok. ++ : ++else ++ { { echo "$as_me:$LINENO: error: newly created file is older than distributed files! ++Check your system clock" >&5 ++echo "$as_me: error: newly created file is older than distributed files! ++Check your system clock" >&2;} ++ { (exit 1); exit 1; }; } ++fi ++rm -f conftest* ++echo "$as_me:$LINENO: result: yes" >&5 ++echo "${ECHO_T}yes" >&6 ++test "$program_prefix" != NONE && ++ program_transform_name="s,^,$program_prefix,;$program_transform_name" ++# Use a double $ so make ignores it. ++test "$program_suffix" != NONE && ++ program_transform_name="s,\$,$program_suffix,;$program_transform_name" ++# Double any \ or $. echo might interpret backslashes. ++# By default was `s,x,x', remove it if useless. ++cat <<\_ACEOF >conftest.sed ++s/[\\$]/&&/g;s/;s,x,x,$// ++_ACEOF ++program_transform_name=`echo $program_transform_name | sed -f conftest.sed` ++rm conftest.sed ++ ++echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5 ++echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6 ++set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,./+-,__p_,'` ++if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ cat >conftest.make <<\_ACEOF ++all: ++ @echo 'ac_maketemp="$(MAKE)"' ++_ACEOF ++# GNU make sometimes prints "make[1]: Entering...", which would confuse us. ++eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=` ++if test -n "$ac_maketemp"; then ++ eval ac_cv_prog_make_${ac_make}_set=yes ++else ++ eval ac_cv_prog_make_${ac_make}_set=no ++fi ++rm -f conftest.make ++fi ++if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then ++ echo "$as_me:$LINENO: result: yes" >&5 ++echo "${ECHO_T}yes" >&6 ++ SET_MAKE= ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++ SET_MAKE="MAKE=${MAKE-make}" ++fi ++ ++ ++# Check whether --enable-multilib or --disable-multilib was given. ++if test "${enable_multilib+set}" = set; then ++ enableval="$enable_multilib" ++ case "${enableval}" in ++ yes) multilib=yes ;; ++ no) multilib=no ;; ++ *) { { echo "$as_me:$LINENO: error: bad value ${enableval} for multilib option" >&5 ++echo "$as_me: error: bad value ${enableval} for multilib option" >&2;} ++ { (exit 1); exit 1; }; } ;; ++ esac ++else ++ multilib=yes ++fi; ++ ++if test "${srcdir}" = "."; then ++ if test "${with_target_subdir}" != "." -a -n "${with_target_subdir}"; then ++ gc_basedir="${srcdir}/${with_multisrctop}../." ++ else ++ gc_basedir="${srcdir}/${with_multisrctop}." ++ fi ++else ++ gc_basedir="${srcdir}/." ++fi ++ ++ac_aux_dir= ++for ac_dir in $gc_basedir/.. $srcdir/$gc_basedir/..; do ++ if test -f $ac_dir/install-sh; then ++ ac_aux_dir=$ac_dir ++ ac_install_sh="$ac_aux_dir/install-sh -c" ++ break ++ elif test -f $ac_dir/install.sh; then ++ ac_aux_dir=$ac_dir ++ ac_install_sh="$ac_aux_dir/install.sh -c" ++ break ++ elif test -f $ac_dir/shtool; then ++ ac_aux_dir=$ac_dir ++ ac_install_sh="$ac_aux_dir/shtool install -c" ++ break ++ fi ++done ++if test -z "$ac_aux_dir"; then ++ { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $gc_basedir/.. $srcdir/$gc_basedir/.." >&5 ++echo "$as_me: error: cannot find install-sh or install.sh in $gc_basedir/.. $srcdir/$gc_basedir/.." >&2;} ++ { (exit 1); exit 1; }; } ++fi ++ac_config_guess="$SHELL $ac_aux_dir/config.guess" ++ac_config_sub="$SHELL $ac_aux_dir/config.sub" ++ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure. ++ ++if :; then :; else ++ # This overrides the previous occurrence for automake, but not for ++ # autoconf, which is exactly what we want. ++ ac_aux_dir= ++for ac_dir in .. $srcdir/..; do ++ if test -f $ac_dir/install-sh; then ++ ac_aux_dir=$ac_dir ++ ac_install_sh="$ac_aux_dir/install-sh -c" ++ break ++ elif test -f $ac_dir/install.sh; then ++ ac_aux_dir=$ac_dir ++ ac_install_sh="$ac_aux_dir/install.sh -c" ++ break ++ elif test -f $ac_dir/shtool; then ++ ac_aux_dir=$ac_dir ++ ac_install_sh="$ac_aux_dir/shtool install -c" ++ break ++ fi ++done ++if test -z "$ac_aux_dir"; then ++ { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in .. $srcdir/.." >&5 ++echo "$as_me: error: cannot find install-sh or install.sh in .. $srcdir/.." >&2;} ++ { (exit 1); exit 1; }; } ++fi ++ac_config_guess="$SHELL $ac_aux_dir/config.guess" ++ac_config_sub="$SHELL $ac_aux_dir/config.sub" ++ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure. ++ ++fi ++ ++echo "$as_me:$LINENO: checking target system type" >&5 ++echo $ECHO_N "checking target system type... $ECHO_C" >&6 ++if test "${ac_cv_target+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ ac_cv_target_alias=$target_alias ++test "x$ac_cv_target_alias" = "x" && ++ ac_cv_target_alias=$ac_cv_host_alias ++ac_cv_target=`$ac_config_sub $ac_cv_target_alias` || ++ { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5 ++echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;} ++ { (exit 1); exit 1; }; } ++ ++fi ++echo "$as_me:$LINENO: result: $ac_cv_target" >&5 ++echo "${ECHO_T}$ac_cv_target" >&6 ++target=$ac_cv_target ++target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'` ++target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'` ++target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'` ++ ++ ++# The aliases save the names the user supplied, while $host etc. ++# will get canonicalized. ++test -n "$target_alias" && ++ test "$program_prefix$program_suffix$program_transform_name" = \ ++ NONENONEs,x,x, && ++ program_prefix=${target_alias}- ++ ++# This works around an automake problem. ++mkinstalldirs="`cd $ac_aux_dir && ${PWDCMD-pwd}`/mkinstalldirs" ++ ++ ++ ++PACKAGE=gc ++ ++VERSION=6.0 ++ ++if test "`cd $srcdir && pwd`" != "`pwd`" && test -f $srcdir/config.status; then ++ { { echo "$as_me:$LINENO: error: source directory already configured; run \"make distclean\" there first" >&5 ++echo "$as_me: error: source directory already configured; run \"make distclean\" there first" >&2;} ++ { (exit 1); exit 1; }; } ++fi ++ ++ ++ ++missing_dir=`cd $ac_aux_dir && pwd` ++echo "$as_me:$LINENO: checking for working aclocal" >&5 ++echo $ECHO_N "checking for working aclocal... $ECHO_C" >&6 ++# Run test in a subshell; some versions of sh will print an error if ++# an executable is not found, even if stderr is redirected. ++# Redirect stdin to placate older versions of autoconf. Sigh. ++if (aclocal --version) < /dev/null > /dev/null 2>&1; then ++ ACLOCAL=aclocal ++ echo "$as_me:$LINENO: result: found" >&5 ++echo "${ECHO_T}found" >&6 ++else ++ ACLOCAL="$missing_dir/missing aclocal" ++ echo "$as_me:$LINENO: result: missing" >&5 ++echo "${ECHO_T}missing" >&6 ++fi ++ ++echo "$as_me:$LINENO: checking for working autoconf" >&5 ++echo $ECHO_N "checking for working autoconf... $ECHO_C" >&6 ++# Run test in a subshell; some versions of sh will print an error if ++# an executable is not found, even if stderr is redirected. ++# Redirect stdin to placate older versions of autoconf. Sigh. ++if (autoconf --version) < /dev/null > /dev/null 2>&1; then ++ AUTOCONF=autoconf ++ echo "$as_me:$LINENO: result: found" >&5 ++echo "${ECHO_T}found" >&6 ++else ++ AUTOCONF="$missing_dir/missing autoconf" ++ echo "$as_me:$LINENO: result: missing" >&5 ++echo "${ECHO_T}missing" >&6 ++fi ++ ++echo "$as_me:$LINENO: checking for working automake" >&5 ++echo $ECHO_N "checking for working automake... $ECHO_C" >&6 ++# Run test in a subshell; some versions of sh will print an error if ++# an executable is not found, even if stderr is redirected. ++# Redirect stdin to placate older versions of autoconf. Sigh. ++if (automake --version) < /dev/null > /dev/null 2>&1; then ++ AUTOMAKE=automake ++ echo "$as_me:$LINENO: result: found" >&5 ++echo "${ECHO_T}found" >&6 ++else ++ AUTOMAKE="$missing_dir/missing automake" ++ echo "$as_me:$LINENO: result: missing" >&5 ++echo "${ECHO_T}missing" >&6 ++fi ++ ++echo "$as_me:$LINENO: checking for working autoheader" >&5 ++echo $ECHO_N "checking for working autoheader... $ECHO_C" >&6 ++# Run test in a subshell; some versions of sh will print an error if ++# an executable is not found, even if stderr is redirected. ++# Redirect stdin to placate older versions of autoconf. Sigh. ++if (autoheader --version) < /dev/null > /dev/null 2>&1; then ++ AUTOHEADER=autoheader ++ echo "$as_me:$LINENO: result: found" >&5 ++echo "${ECHO_T}found" >&6 ++else ++ AUTOHEADER="$missing_dir/missing autoheader" ++ echo "$as_me:$LINENO: result: missing" >&5 ++echo "${ECHO_T}missing" >&6 ++fi ++ ++echo "$as_me:$LINENO: checking for working makeinfo" >&5 ++echo $ECHO_N "checking for working makeinfo... $ECHO_C" >&6 ++# Run test in a subshell; some versions of sh will print an error if ++# an executable is not found, even if stderr is redirected. ++# Redirect stdin to placate older versions of autoconf. Sigh. ++if (makeinfo --version) < /dev/null > /dev/null 2>&1; then ++ MAKEINFO=makeinfo ++ echo "$as_me:$LINENO: result: found" >&5 ++echo "${ECHO_T}found" >&6 ++else ++ MAKEINFO="$missing_dir/missing makeinfo" ++ echo "$as_me:$LINENO: result: missing" >&5 ++echo "${ECHO_T}missing" >&6 ++fi ++ ++ ++ ++# FIXME: We temporarily define our own version of AC_PROG_CC. This is ++# copied from autoconf 2.12, but does not call AC_PROG_CC_WORKS. We ++# are probably using a cross compiler, which will not be able to fully ++# link an executable. This should really be fixed in autoconf ++# itself. ++ ++ ++ ++ ++# Extract the first word of "gcc", so it can be a program name with args. ++set dummy gcc; ac_word=$2 ++echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 ++if test "${ac_cv_prog_CC+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$CC"; then ++ ac_cv_prog_CC="$CC" # Let the user override the test. ++else ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ++ ac_cv_prog_CC="gcc" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++ ++fi ++fi ++CC=$ac_cv_prog_CC ++if test -n "$CC"; then ++ echo "$as_me:$LINENO: result: $CC" >&5 ++echo "${ECHO_T}$CC" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++if test -z "$CC"; then ++ # Extract the first word of "cc", so it can be a program name with args. ++set dummy cc; ac_word=$2 ++echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 ++if test "${ac_cv_prog_CC+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$CC"; then ++ ac_cv_prog_CC="$CC" # Let the user override the test. ++else ++ ac_prog_rejected=no ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ++ if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then ++ ac_prog_rejected=yes ++ continue ++ fi ++ ac_cv_prog_CC="cc" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++ ++if test $ac_prog_rejected = yes; then ++ # We found a bogon in the path, so make sure we never use it. ++ set dummy $ac_cv_prog_CC ++ shift ++ if test $@%:@ != 0; then ++ # We chose a different compiler from the bogus one. ++ # However, it has the same basename, so the bogon will be chosen ++ # first if we set CC to just the basename; use the full file name. ++ shift ++ ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@" ++ fi ++fi ++fi ++fi ++CC=$ac_cv_prog_CC ++if test -n "$CC"; then ++ echo "$as_me:$LINENO: result: $CC" >&5 ++echo "${ECHO_T}$CC" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++ test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable cc found in \$PATH" >&5 ++echo "$as_me: error: no acceptable cc found in \$PATH" >&2;} ++ { (exit 1); exit 1; }; } ++fi ++ ++AC_PROG_CC_GNU ++ ++if test $ac_cv_c_compiler_gnu = yes; then ++ GCC=yes ++ ac_test_CFLAGS="${CFLAGS+set}" ++ ac_save_CFLAGS="$CFLAGS" ++ CFLAGS= ++ AC_PROG_CC_G ++ if test "$ac_test_CFLAGS" = set; then ++ CFLAGS="$ac_save_CFLAGS" ++ elif test $ac_cv_prog_cc_g = yes; then ++ CFLAGS="-g -O2" ++ else ++ CFLAGS="-O2" ++ fi ++else ++ GCC= ++ test "${CFLAGS+set}" = set || CFLAGS="-g" ++fi ++ ++ ++# Likewise for AC_PROG_CXX. ++ ++ ++ ++for ac_prog in $CCC c++ g++ gcc CC cxx cc++ ++do ++ # Extract the first word of "$ac_prog", so it can be a program name with args. ++set dummy $ac_prog; ac_word=$2 ++echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 ++if test "${ac_cv_prog_CXX+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$CXX"; then ++ ac_cv_prog_CXX="$CXX" # Let the user override the test. ++else ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ++ ac_cv_prog_CXX="$ac_prog" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++ ++fi ++fi ++CXX=$ac_cv_prog_CXX ++if test -n "$CXX"; then ++ echo "$as_me:$LINENO: result: $CXX" >&5 ++echo "${ECHO_T}$CXX" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++ test -n "$CXX" && break ++done ++test -n "$CXX" || CXX="gcc" ++ ++test -z "$CXX" && { { echo "$as_me:$LINENO: error: no acceptable c++ found in \$PATH" >&5 ++echo "$as_me: error: no acceptable c++ found in \$PATH" >&2;} ++ { (exit 1); exit 1; }; } ++ ++AC_PROG_CXX_GNU ++ ++if test $ac_cv_cxx_compiler_gnu = yes; then ++ GXX=yes ++ ac_test_CXXFLAGS="${CXXFLAGS+set}" ++ ac_save_CXXFLAGS="$CXXFLAGS" ++ CXXFLAGS= ++ AC_PROG_CXX_G ++ if test "$ac_test_CXXFLAGS" = set; then ++ CXXFLAGS="$ac_save_CXXFLAGS" ++ elif test $ac_cv_prog_cxx_g = yes; then ++ CXXFLAGS="-g -O2" ++ else ++ CXXFLAGS="-O2" ++ fi ++else ++ GXX= ++ test "${CXXFLAGS+set}" = set || CXXFLAGS="-g" ++fi ++ ++ ++# AC_CHECK_TOOL does AC_REQUIRE (AC_CANONICAL_BUILD). If we don't ++# run it explicitly here, it will be run implicitly before ++# NEWLIB_CONFIGURE, which doesn't work because that means that it will ++# be run before AC_CANONICAL_HOST. ++ ++ ++if test -n "$ac_tool_prefix"; then ++ # Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args. ++set dummy ${ac_tool_prefix}as; ac_word=$2 ++echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 ++if test "${ac_cv_prog_AS+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$AS"; then ++ ac_cv_prog_AS="$AS" # Let the user override the test. ++else ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ++ ac_cv_prog_AS="${ac_tool_prefix}as" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++ ++fi ++fi ++AS=$ac_cv_prog_AS ++if test -n "$AS"; then ++ echo "$as_me:$LINENO: result: $AS" >&5 ++echo "${ECHO_T}$AS" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++fi ++if test -z "$ac_cv_prog_AS"; then ++ ac_ct_AS=$AS ++ # Extract the first word of "as", so it can be a program name with args. ++set dummy as; ac_word=$2 ++echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 ++if test "${ac_cv_prog_ac_ct_AS+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$ac_ct_AS"; then ++ ac_cv_prog_ac_ct_AS="$ac_ct_AS" # Let the user override the test. ++else ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ++ ac_cv_prog_ac_ct_AS="as" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++ ++fi ++fi ++ac_ct_AS=$ac_cv_prog_ac_ct_AS ++if test -n "$ac_ct_AS"; then ++ echo "$as_me:$LINENO: result: $ac_ct_AS" >&5 ++echo "${ECHO_T}$ac_ct_AS" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++ AS=$ac_ct_AS ++else ++ AS="$ac_cv_prog_AS" ++fi ++ ++if test -n "$ac_tool_prefix"; then ++ # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args. ++set dummy ${ac_tool_prefix}ar; ac_word=$2 ++echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 ++if test "${ac_cv_prog_AR+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$AR"; then ++ ac_cv_prog_AR="$AR" # Let the user override the test. ++else ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ++ ac_cv_prog_AR="${ac_tool_prefix}ar" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++ ++fi ++fi ++AR=$ac_cv_prog_AR ++if test -n "$AR"; then ++ echo "$as_me:$LINENO: result: $AR" >&5 ++echo "${ECHO_T}$AR" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++fi ++if test -z "$ac_cv_prog_AR"; then ++ ac_ct_AR=$AR ++ # Extract the first word of "ar", so it can be a program name with args. ++set dummy ar; ac_word=$2 ++echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 ++if test "${ac_cv_prog_ac_ct_AR+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$ac_ct_AR"; then ++ ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test. ++else ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ++ ac_cv_prog_ac_ct_AR="ar" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++ ++fi ++fi ++ac_ct_AR=$ac_cv_prog_ac_ct_AR ++if test -n "$ac_ct_AR"; then ++ echo "$as_me:$LINENO: result: $ac_ct_AR" >&5 ++echo "${ECHO_T}$ac_ct_AR" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++ AR=$ac_ct_AR ++else ++ AR="$ac_cv_prog_AR" ++fi ++ ++if test -n "$ac_tool_prefix"; then ++ # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args. ++set dummy ${ac_tool_prefix}ranlib; ac_word=$2 ++echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 ++if test "${ac_cv_prog_RANLIB+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$RANLIB"; then ++ ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test. ++else ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ++ ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++ ++fi ++fi ++RANLIB=$ac_cv_prog_RANLIB ++if test -n "$RANLIB"; then ++ echo "$as_me:$LINENO: result: $RANLIB" >&5 ++echo "${ECHO_T}$RANLIB" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++fi ++if test -z "$ac_cv_prog_RANLIB"; then ++ ac_ct_RANLIB=$RANLIB ++ # Extract the first word of "ranlib", so it can be a program name with args. ++set dummy ranlib; ac_word=$2 ++echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 ++if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$ac_ct_RANLIB"; then ++ ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test. ++else ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ++ ac_cv_prog_ac_ct_RANLIB="ranlib" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++ ++ test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":" ++fi ++fi ++ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB ++if test -n "$ac_ct_RANLIB"; then ++ echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5 ++echo "${ECHO_T}$ac_ct_RANLIB" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++ RANLIB=$ac_ct_RANLIB ++else ++ RANLIB="$ac_cv_prog_RANLIB" ++fi ++ ++ ++# Find a good install program. We prefer a C program (faster), ++# so one script is as good as another. But avoid the broken or ++# incompatible versions: ++# SysV /etc/install, /usr/sbin/install ++# SunOS /usr/etc/install ++# IRIX /sbin/install ++# AIX /bin/install ++# AmigaOS /C/install, which installs bootblocks on floppy discs ++# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag ++# AFS /usr/afsws/bin/install, which mishandles nonexistent args ++# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff" ++# ./install, which can be erroneously created by make from ./install.sh. ++echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5 ++echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6 ++if test -z "$INSTALL"; then ++if test "${ac_cv_path_install+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ # Account for people who put trailing slashes in PATH elements. ++case $as_dir/ in ++ ./ | .// | /cC/* | \ ++ /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \ ++ /usr/ucb/* ) ;; ++ *) ++ # OSF1 and SCO ODT 3.0 have their own names for install. ++ # Don't use installbsd from OSF since it installs stuff as root ++ # by default. ++ for ac_prog in ginstall scoinst install; do ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then ++ if test $ac_prog = install && ++ grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then ++ # AIX install. It has an incompatible calling convention. ++ : ++ elif test $ac_prog = install && ++ grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then ++ # program-specific install script used by HP pwplus--don't use. ++ : ++ else ++ ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c" ++ break 3 ++ fi ++ fi ++ done ++ done ++ ;; ++esac ++done ++ ++ ++fi ++ if test "${ac_cv_path_install+set}" = set; then ++ INSTALL=$ac_cv_path_install ++ else ++ # As a last resort, use the slow shell script. We don't cache a ++ # path for INSTALL within a source directory, because that will ++ # break other packages using the cache if that directory is ++ # removed, or if the path is relative. ++ INSTALL=$ac_install_sh ++ fi ++fi ++echo "$as_me:$LINENO: result: $INSTALL" >&5 ++echo "${ECHO_T}$INSTALL" >&6 ++ ++# Use test -z because SunOS4 sh mishandles braces in ${var-val}. ++# It thinks the first close brace ends the variable substitution. ++test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}' ++ ++test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}' ++ ++test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644' ++ ++ ++echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5 ++echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6 ++ # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given. ++if test "${enable_maintainer_mode+set}" = set; then ++ enableval="$enable_maintainer_mode" ++ USE_MAINTAINER_MODE=$enableval ++else ++ USE_MAINTAINER_MODE=no ++fi; ++ echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5 ++echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6 ++ ++ ++if test $USE_MAINTAINER_MODE = yes; then ++ MAINTAINER_MODE_TRUE= ++ MAINTAINER_MODE_FALSE='#' ++else ++ MAINTAINER_MODE_TRUE='#' ++ MAINTAINER_MODE_FALSE= ++fi ++ MAINT=$MAINTAINER_MODE_TRUE ++ ++ ++ ++# We need AC_EXEEXT to keep automake happy in cygnus mode. However, ++# at least currently, we never actually build a program, so we never ++# need to use $(EXEEXT). Moreover, the test for EXEEXT normally ++# fails, because we are probably configuring with a cross compiler ++# which can't create executables. So we include AC_EXEEXT to keep ++# automake happy, but we don't execute it, since we don't care about ++# the result. ++if false; then ++ # autoconf 2.50 runs AC_EXEEXT by default, and the macro expands ++ # to nothing, so nothing would remain between `then' and `fi' if it ++ # were not for the `:' below. ++ : ++ ++fi ++ ++. ${srcdir}/configure.host ++ ++case ${gc_basedir} in ++/* | A-Za-z:/\\*) gc_flagbasedir=${gc_basedir} ;; ++*) gc_flagbasedir='$(top_builddir)/'${gc_basedir} ;; ++esac ++ ++gc_cflags="${gc_cflags} -I"'$(top_builddir)'"/./targ-include -I${gc_flagbasedir}/libc/include" ++case "${host}" in ++ *-*-cygwin32*) ++ gc_cflags="${gc_cflags} -I${gc_flagbasedir}/../winsup/include" ++ ;; ++esac ++ ++ ++GC_CFLAGS=${gc_cflags} ++ ++ ++ ++# Check whether --enable-shared or --disable-shared was given. ++if test "${enable_shared+set}" = set; then ++ enableval="$enable_shared" ++ p=${PACKAGE-default} ++case $enableval in ++yes) enable_shared=yes ;; ++no) enable_shared=no ;; ++*) ++ enable_shared=no ++ # Look at the argument we got. We use all the common list separators. ++ IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:," ++ for pkg in $enableval; do ++ if test "X$pkg" = "X$p"; then ++ enable_shared=yes ++ fi ++ done ++ IFS="$ac_save_ifs" ++ ;; ++esac ++else ++ enable_shared=yes ++fi; ++# Check whether --enable-static or --disable-static was given. ++if test "${enable_static+set}" = set; then ++ enableval="$enable_static" ++ p=${PACKAGE-default} ++case $enableval in ++yes) enable_static=yes ;; ++no) enable_static=no ;; ++*) ++ enable_static=no ++ # Look at the argument we got. We use all the common list separators. ++ IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:," ++ for pkg in $enableval; do ++ if test "X$pkg" = "X$p"; then ++ enable_static=yes ++ fi ++ done ++ IFS="$ac_save_ifs" ++ ;; ++esac ++else ++ enable_static=yes ++fi; ++# Check whether --enable-fast-install or --disable-fast-install was given. ++if test "${enable_fast_install+set}" = set; then ++ enableval="$enable_fast_install" ++ p=${PACKAGE-default} ++case $enableval in ++yes) enable_fast_install=yes ;; ++no) enable_fast_install=no ;; ++*) ++ enable_fast_install=no ++ # Look at the argument we got. We use all the common list separators. ++ IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:," ++ for pkg in $enableval; do ++ if test "X$pkg" = "X$p"; then ++ enable_fast_install=yes ++ fi ++ done ++ IFS="$ac_save_ifs" ++ ;; ++esac ++else ++ enable_fast_install=yes ++fi; ++ ++# Check whether --with-gnu-ld or --without-gnu-ld was given. ++if test "${with_gnu_ld+set}" = set; then ++ withval="$with_gnu_ld" ++ test "$withval" = no || with_gnu_ld=yes ++else ++ with_gnu_ld=no ++fi; ++ac_prog=ld ++if test "$GCC" = yes; then ++ # Check if gcc -print-prog-name=ld gives a path. ++ echo "$as_me:$LINENO: checking for ld used by GCC" >&5 ++echo $ECHO_N "checking for ld used by GCC... $ECHO_C" >&6 ++ case $host in ++ *-*-mingw*) ++ # gcc leaves a trailing carriage return which upsets mingw ++ ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;; ++ *) ++ ac_prog=`($CC -print-prog-name=ld) 2>&5` ;; ++ esac ++ case $ac_prog in ++ # Accept absolute paths. ++ [\\/]* | [A-Za-z]:[\\/]*) ++ re_direlt='/[^/][^/]*/\.\./' ++ # Canonicalize the path of ld ++ ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'` ++ while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do ++ ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"` ++ done ++ test -z "$LD" && LD="$ac_prog" ++ ;; ++ "") ++ # If it fails, then pretend we aren't using GCC. ++ ac_prog=ld ++ ;; ++ *) ++ # If it is relative, then search for the first ld in PATH. ++ with_gnu_ld=unknown ++ ;; ++ esac ++elif test "$with_gnu_ld" = yes; then ++ echo "$as_me:$LINENO: checking for GNU ld" >&5 ++echo $ECHO_N "checking for GNU ld... $ECHO_C" >&6 ++else ++ echo "$as_me:$LINENO: checking for non-GNU ld" >&5 ++echo $ECHO_N "checking for non-GNU ld... $ECHO_C" >&6 ++fi ++if test "${lt_cv_path_LD+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -z "$LD"; then ++ IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}" ++ for ac_dir in $PATH; do ++ test -z "$ac_dir" && ac_dir=. ++ if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then ++ lt_cv_path_LD="$ac_dir/$ac_prog" ++ # Check to see if the program is GNU ld. I'd rather use --version, ++ # but apparently some GNU ld's only accept -v. ++ # Break only if it was the GNU/non-GNU ld that we prefer. ++ if "$lt_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then ++ test "$with_gnu_ld" != no && break ++ else ++ test "$with_gnu_ld" != yes && break ++ fi ++ fi ++ done ++ IFS="$ac_save_ifs" ++else ++ lt_cv_path_LD="$LD" # Let the user override the test with a path. ++fi ++fi ++ ++LD="$lt_cv_path_LD" ++if test -n "$LD"; then ++ echo "$as_me:$LINENO: result: $LD" >&5 ++echo "${ECHO_T}$LD" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++test -z "$LD" && { { echo "$as_me:$LINENO: error: no acceptable ld found in \$PATH" >&5 ++echo "$as_me: error: no acceptable ld found in \$PATH" >&2;} ++ { (exit 1); exit 1; }; } ++echo "$as_me:$LINENO: checking if the linker ($LD) is GNU ld" >&5 ++echo $ECHO_N "checking if the linker ($LD) is GNU ld... $ECHO_C" >&6 ++if test "${lt_cv_prog_gnu_ld+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ # I'd rather use --version here, but apparently some GNU ld's only accept -v. ++if $LD -v 2>&1 &5; then ++ lt_cv_prog_gnu_ld=yes ++else ++ lt_cv_prog_gnu_ld=no ++fi ++fi ++echo "$as_me:$LINENO: result: $lt_cv_prog_gnu_ld" >&5 ++echo "${ECHO_T}$lt_cv_prog_gnu_ld" >&6 ++with_gnu_ld=$lt_cv_prog_gnu_ld ++ ++ ++echo "$as_me:$LINENO: checking for $LD option to reload object files" >&5 ++echo $ECHO_N "checking for $LD option to reload object files... $ECHO_C" >&6 ++if test "${lt_cv_ld_reload_flag+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ lt_cv_ld_reload_flag='-r' ++fi ++echo "$as_me:$LINENO: result: $lt_cv_ld_reload_flag" >&5 ++echo "${ECHO_T}$lt_cv_ld_reload_flag" >&6 ++reload_flag=$lt_cv_ld_reload_flag ++test -n "$reload_flag" && reload_flag=" $reload_flag" ++ ++echo "$as_me:$LINENO: checking for BSD-compatible nm" >&5 ++echo $ECHO_N "checking for BSD-compatible nm... $ECHO_C" >&6 ++if test "${lt_cv_path_NM+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$NM"; then ++ # Let the user override the test. ++ lt_cv_path_NM="$NM" ++else ++ IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}" ++ for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do ++ test -z "$ac_dir" && ac_dir=. ++ tmp_nm=$ac_dir/${ac_tool_prefix}nm ++ if test -f $tmp_nm || test -f $tmp_nm$ac_exeext ; then ++ # Check to see if the nm accepts a BSD-compat flag. ++ # Adding the `sed 1q' prevents false positives on HP-UX, which says: ++ # nm: unknown option "B" ignored ++ # Tru64's nm complains that /dev/null is an invalid object file ++ if ($tmp_nm -B /dev/null 2>&1 | sed '1q'; exit 0) | egrep '(/dev/null|Invalid file or object type)' >/dev/null; then ++ lt_cv_path_NM="$tmp_nm -B" ++ break ++ elif ($tmp_nm -p /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then ++ lt_cv_path_NM="$tmp_nm -p" ++ break ++ else ++ lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but ++ continue # so that we can try to find one that supports BSD flags ++ fi ++ fi ++ done ++ IFS="$ac_save_ifs" ++ test -z "$lt_cv_path_NM" && lt_cv_path_NM=nm ++fi ++fi ++ ++NM="$lt_cv_path_NM" ++echo "$as_me:$LINENO: result: $NM" >&5 ++echo "${ECHO_T}$NM" >&6 ++ ++echo "$as_me:$LINENO: checking whether ln -s works" >&5 ++echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6 ++LN_S=$as_ln_s ++if test "$LN_S" = "ln -s"; then ++ echo "$as_me:$LINENO: result: yes" >&5 ++echo "${ECHO_T}yes" >&6 ++else ++ echo "$as_me:$LINENO: result: no, using $LN_S" >&5 ++echo "${ECHO_T}no, using $LN_S" >&6 ++fi ++ ++echo "$as_me:$LINENO: checking how to recognise dependant libraries" >&5 ++echo $ECHO_N "checking how to recognise dependant libraries... $ECHO_C" >&6 ++if test "${lt_cv_deplibs_check_method+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ lt_cv_file_magic_cmd='$MAGIC_CMD' ++lt_cv_file_magic_test_file= ++lt_cv_deplibs_check_method='unknown' ++# Need to set the preceding variable on all platforms that support ++# interlibrary dependencies. ++# 'none' -- dependencies not supported. ++# `unknown' -- same as none, but documents that we really don't know. ++# 'pass_all' -- all dependencies passed with no checks. ++# 'test_compile' -- check by making test program. ++# 'file_magic [regex]' -- check by looking for files in library path ++# which responds to the $file_magic_cmd with a given egrep regex. ++# If you have `file' or equivalent on your system and you're not sure ++# whether `pass_all' will *always* work, you probably want this one. ++ ++case $host_os in ++aix*) ++ lt_cv_deplibs_check_method=pass_all ++ ;; ++ ++beos*) ++ lt_cv_deplibs_check_method=pass_all ++ ;; ++ ++bsdi4*) ++ lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)' ++ lt_cv_file_magic_cmd='/usr/bin/file -L' ++ lt_cv_file_magic_test_file=/shlib/libc.so ++ ;; ++ ++cygwin* | mingw* |pw32*) ++ lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?' ++ lt_cv_file_magic_cmd='$OBJDUMP -f' ++ ;; ++ ++darwin* | rhapsody*) ++ lt_cv_deplibs_check_method='file_magic Mach-O dynamically linked shared library' ++ lt_cv_file_magic_cmd='/usr/bin/file -L' ++ case "$host_os" in ++ rhapsody* | darwin1.012) ++ lt_cv_file_magic_test_file='/System/Library/Frameworks/System.framework/System' ++ ;; ++ *) # Darwin 1.3 on ++ lt_cv_file_magic_test_file='/usr/lib/libSystem.dylib' ++ ;; ++ esac ++ ;; ++ ++freebsd* ) ++ if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then ++ case $host_cpu in ++ i*86 ) ++ # Not sure whether the presence of OpenBSD here was a mistake. ++ # Let's accept both of them until this is cleared up. ++ lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD)/i[3-9]86 (compact )?demand paged shared library' ++ lt_cv_file_magic_cmd=/usr/bin/file ++ lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*` ++ ;; ++ esac ++ else ++ lt_cv_deplibs_check_method=pass_all ++ fi ++ ;; ++ ++gnu*) ++ lt_cv_deplibs_check_method=pass_all ++ ;; ++ ++hpux10.20*|hpux11*) ++ case $host_cpu in ++ hppa*) ++ lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9].[0-9]) shared library' ++ lt_cv_file_magic_cmd=/usr/bin/file ++ lt_cv_file_magic_test_file=/usr/lib/libc.sl ++ ;; ++ ia64*) ++ lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - IA64' ++ lt_cv_file_magic_cmd=/usr/bin/file ++ lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so ++ ;; ++ esac ++ ;; ++ ++irix5* | irix6*) ++ case $host_os in ++ irix5*) ++ # this will be overridden with pass_all, but let us keep it just in case ++ lt_cv_deplibs_check_method="file_magic ELF 32-bit MSB dynamic lib MIPS - version 1" ++ ;; ++ *) ++ case $LD in ++ *-32|*"-32 ") libmagic=32-bit;; ++ *-n32|*"-n32 ") libmagic=N32;; ++ *-64|*"-64 ") libmagic=64-bit;; ++ *) libmagic=never-match;; ++ esac ++ # this will be overridden with pass_all, but let us keep it just in case ++ lt_cv_deplibs_check_method="file_magic ELF ${libmagic} MSB mips-[1234] dynamic lib MIPS - version 1" ++ ;; ++ esac ++ lt_cv_file_magic_test_file=`echo /lib${libsuff}/libc.so*` ++ lt_cv_deplibs_check_method=pass_all ++ ;; ++ ++# This must be Linux ELF. ++linux-gnu*) ++ case $host_cpu in ++ alpha* | hppa* | i*86 | powerpc* | sparc* | ia64* ) ++ lt_cv_deplibs_check_method=pass_all ;; ++ *) ++ # glibc up to 2.1.1 does not perform some relocations on ARM ++ lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB (shared object|dynamic lib )' ;; ++ esac ++ lt_cv_file_magic_test_file=`echo /lib/libc.so* /lib/libc-*.so` ++ ;; ++ ++netbsd*) ++ if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then ++ lt_cv_deplibs_check_method='match_pattern /lib[^/\.]+\.so\.[0-9]+\.[0-9]+$' ++ else ++ lt_cv_deplibs_check_method='match_pattern /lib[^/\.]+\.so$' ++ fi ++ ;; ++ ++newsos6) ++ lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (executable|dynamic lib)' ++ lt_cv_file_magic_cmd=/usr/bin/file ++ lt_cv_file_magic_test_file=/usr/lib/libnls.so ++ ;; ++ ++osf3* | osf4* | osf5*) ++ # this will be overridden with pass_all, but let us keep it just in case ++ lt_cv_deplibs_check_method='file_magic COFF format alpha shared library' ++ lt_cv_file_magic_test_file=/shlib/libc.so ++ lt_cv_deplibs_check_method=pass_all ++ ;; ++ ++sco3.2v5*) ++ lt_cv_deplibs_check_method=pass_all ++ ;; ++ ++solaris*) ++ lt_cv_deplibs_check_method=pass_all ++ lt_cv_file_magic_test_file=/lib/libc.so ++ ;; ++ ++sysv5uw[78]* | sysv4*uw2*) ++ lt_cv_deplibs_check_method=pass_all ++ ;; ++ ++sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) ++ case $host_vendor in ++ ncr) ++ lt_cv_deplibs_check_method=pass_all ++ ;; ++ motorola) ++ lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib) M[0-9][0-9]* Version [0-9]' ++ lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*` ++ ;; ++ esac ++ ;; ++esac ++ ++fi ++echo "$as_me:$LINENO: result: $lt_cv_deplibs_check_method" >&5 ++echo "${ECHO_T}$lt_cv_deplibs_check_method" >&6 ++file_magic_cmd=$lt_cv_file_magic_cmd ++deplibs_check_method=$lt_cv_deplibs_check_method ++ ++ ++ ++ ++# Autoconf 2.13's AC_OBJEXT and AC_EXEEXT macros only works for C compilers! ++ ++# Only perform the check for file, if the check method requires it ++case $deplibs_check_method in ++file_magic*) ++ if test "$file_magic_cmd" = '$MAGIC_CMD'; then ++ echo "$as_me:$LINENO: checking for ${ac_tool_prefix}file" >&5 ++echo $ECHO_N "checking for ${ac_tool_prefix}file... $ECHO_C" >&6 ++if test "${lt_cv_path_MAGIC_CMD+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ case $MAGIC_CMD in ++ /*) ++ lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path. ++ ;; ++ ?:/*) ++ lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path. ++ ;; ++ *) ++ ac_save_MAGIC_CMD="$MAGIC_CMD" ++ IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS=":" ++ ac_dummy="/usr/bin:$PATH" ++ for ac_dir in $ac_dummy; do ++ test -z "$ac_dir" && ac_dir=. ++ if test -f $ac_dir/${ac_tool_prefix}file; then ++ lt_cv_path_MAGIC_CMD="$ac_dir/${ac_tool_prefix}file" ++ if test -n "$file_magic_test_file"; then ++ case $deplibs_check_method in ++ "file_magic "*) ++ file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`" ++ MAGIC_CMD="$lt_cv_path_MAGIC_CMD" ++ if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null | ++ egrep "$file_magic_regex" > /dev/null; then ++ : ++ else ++ cat <&2 ++ ++*** Warning: the command libtool uses to detect shared libraries, ++*** $file_magic_cmd, produces output that libtool cannot recognize. ++*** The result is that libtool may fail to recognize shared libraries ++*** as such. This will affect the creation of libtool libraries that ++*** depend on shared libraries, but programs linked with such libtool ++*** libraries will work regardless of this problem. Nevertheless, you ++*** may want to report the problem to your system manager and/or to ++*** bug-libtool@gnu.org ++ ++EOF ++ fi ;; ++ esac ++ fi ++ break ++ fi ++ done ++ IFS="$ac_save_ifs" ++ MAGIC_CMD="$ac_save_MAGIC_CMD" ++ ;; ++esac ++fi ++ ++MAGIC_CMD="$lt_cv_path_MAGIC_CMD" ++if test -n "$MAGIC_CMD"; then ++ echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5 ++echo "${ECHO_T}$MAGIC_CMD" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++if test -z "$lt_cv_path_MAGIC_CMD"; then ++ if test -n "$ac_tool_prefix"; then ++ echo "$as_me:$LINENO: checking for file" >&5 ++echo $ECHO_N "checking for file... $ECHO_C" >&6 ++if test "${lt_cv_path_MAGIC_CMD+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ case $MAGIC_CMD in ++ /*) ++ lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path. ++ ;; ++ ?:/*) ++ lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path. ++ ;; ++ *) ++ ac_save_MAGIC_CMD="$MAGIC_CMD" ++ IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS=":" ++ ac_dummy="/usr/bin:$PATH" ++ for ac_dir in $ac_dummy; do ++ test -z "$ac_dir" && ac_dir=. ++ if test -f $ac_dir/file; then ++ lt_cv_path_MAGIC_CMD="$ac_dir/file" ++ if test -n "$file_magic_test_file"; then ++ case $deplibs_check_method in ++ "file_magic "*) ++ file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`" ++ MAGIC_CMD="$lt_cv_path_MAGIC_CMD" ++ if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null | ++ egrep "$file_magic_regex" > /dev/null; then ++ : ++ else ++ cat <&2 ++ ++*** Warning: the command libtool uses to detect shared libraries, ++*** $file_magic_cmd, produces output that libtool cannot recognize. ++*** The result is that libtool may fail to recognize shared libraries ++*** as such. This will affect the creation of libtool libraries that ++*** depend on shared libraries, but programs linked with such libtool ++*** libraries will work regardless of this problem. Nevertheless, you ++*** may want to report the problem to your system manager and/or to ++*** bug-libtool@gnu.org ++ ++EOF ++ fi ;; ++ esac ++ fi ++ break ++ fi ++ done ++ IFS="$ac_save_ifs" ++ MAGIC_CMD="$ac_save_MAGIC_CMD" ++ ;; ++esac ++fi ++ ++MAGIC_CMD="$lt_cv_path_MAGIC_CMD" ++if test -n "$MAGIC_CMD"; then ++ echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5 ++echo "${ECHO_T}$MAGIC_CMD" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++ else ++ MAGIC_CMD=: ++ fi ++fi ++ ++ fi ++ ;; ++esac ++ ++if test -n "$ac_tool_prefix"; then ++ # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args. ++set dummy ${ac_tool_prefix}ranlib; ac_word=$2 ++echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 ++if test "${ac_cv_prog_RANLIB+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$RANLIB"; then ++ ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test. ++else ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ++ ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++ ++fi ++fi ++RANLIB=$ac_cv_prog_RANLIB ++if test -n "$RANLIB"; then ++ echo "$as_me:$LINENO: result: $RANLIB" >&5 ++echo "${ECHO_T}$RANLIB" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++fi ++if test -z "$ac_cv_prog_RANLIB"; then ++ ac_ct_RANLIB=$RANLIB ++ # Extract the first word of "ranlib", so it can be a program name with args. ++set dummy ranlib; ac_word=$2 ++echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 ++if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$ac_ct_RANLIB"; then ++ ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test. ++else ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ++ ac_cv_prog_ac_ct_RANLIB="ranlib" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++ ++ test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":" ++fi ++fi ++ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB ++if test -n "$ac_ct_RANLIB"; then ++ echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5 ++echo "${ECHO_T}$ac_ct_RANLIB" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++ RANLIB=$ac_ct_RANLIB ++else ++ RANLIB="$ac_cv_prog_RANLIB" ++fi ++ ++if test -n "$ac_tool_prefix"; then ++ # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args. ++set dummy ${ac_tool_prefix}strip; ac_word=$2 ++echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 ++if test "${ac_cv_prog_STRIP+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$STRIP"; then ++ ac_cv_prog_STRIP="$STRIP" # Let the user override the test. ++else ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ++ ac_cv_prog_STRIP="${ac_tool_prefix}strip" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++ ++fi ++fi ++STRIP=$ac_cv_prog_STRIP ++if test -n "$STRIP"; then ++ echo "$as_me:$LINENO: result: $STRIP" >&5 ++echo "${ECHO_T}$STRIP" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++fi ++if test -z "$ac_cv_prog_STRIP"; then ++ ac_ct_STRIP=$STRIP ++ # Extract the first word of "strip", so it can be a program name with args. ++set dummy strip; ac_word=$2 ++echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 ++if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$ac_ct_STRIP"; then ++ ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test. ++else ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ++ ac_cv_prog_ac_ct_STRIP="strip" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++ ++ test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":" ++fi ++fi ++ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP ++if test -n "$ac_ct_STRIP"; then ++ echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5 ++echo "${ECHO_T}$ac_ct_STRIP" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++ STRIP=$ac_ct_STRIP ++else ++ STRIP="$ac_cv_prog_STRIP" ++fi ++ ++ ++# Check for any special flags to pass to ltconfig. ++libtool_flags="--cache-file=$cache_file" ++test "$enable_shared" = no && libtool_flags="$libtool_flags --disable-shared" ++test "$enable_static" = no && libtool_flags="$libtool_flags --disable-static" ++test "$enable_fast_install" = no && libtool_flags="$libtool_flags --disable-fast-install" ++test "$GCC" = yes && libtool_flags="$libtool_flags --with-gcc" ++test "$lt_cv_prog_gnu_ld" = yes && libtool_flags="$libtool_flags --with-gnu-ld" ++ ++ ++# Check whether --enable-libtool-lock or --disable-libtool-lock was given. ++if test "${enable_libtool_lock+set}" = set; then ++ enableval="$enable_libtool_lock" ++ ++fi; ++test "x$enable_libtool_lock" = xno && libtool_flags="$libtool_flags --disable-lock" ++test x"$silent" = xyes && libtool_flags="$libtool_flags --silent" ++ ++ ++# Check whether --with-pic or --without-pic was given. ++if test "${with_pic+set}" = set; then ++ withval="$with_pic" ++ pic_mode="$withval" ++else ++ pic_mode=default ++fi; ++test x"$pic_mode" = xyes && libtool_flags="$libtool_flags --prefer-pic" ++test x"$pic_mode" = xno && libtool_flags="$libtool_flags --prefer-non-pic" ++ ++# Some flags need to be propagated to the compiler or linker for good ++# libtool support. ++case $host in ++*-*-irix6*) ++ # Find out which ABI we are using. ++ echo '#line __oline__ "configure"' > conftest.$ac_ext ++ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 ++ (eval $ac_compile) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; then ++ case `/usr/bin/file conftest.$ac_objext` in ++ *32-bit*) ++ LD="${LD-ld} -32" ++ ;; ++ *N32*) ++ LD="${LD-ld} -n32" ++ ;; ++ *64-bit*) ++ LD="${LD-ld} -64" ++ ;; ++ esac ++ fi ++ rm -rf conftest* ++ ;; ++ ++ia64-*-hpux*) ++ # Find out which ABI we are using. ++ echo 'int i;' > conftest.$ac_ext ++ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 ++ (eval $ac_compile) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; then ++ case "`/usr/bin/file conftest.o`" in ++ *ELF-32*) ++ HPUX_IA64_MODE="32" ++ ;; ++ *ELF-64*) ++ HPUX_IA64_MODE="64" ++ ;; ++ esac ++ fi ++ rm -rf conftest* ++ ;; ++ ++x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*|s390*-*linux*|sparc*-*linux*) ++ # Find out which ABI we are using. ++ echo 'int i;' > conftest.$ac_ext ++ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 ++ (eval $ac_compile) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; then ++ case "`/usr/bin/file conftest.o`" in ++ *32-bit*) ++ case $host in ++ x86_64-*linux*) ++ LD="${LD-ld} -m elf_i386" ++ ;; ++ ppc64-*linux*) ++ LD="${LD-ld} -m elf32ppclinux" ++ ;; ++ s390x-*linux*) ++ LD="${LD-ld} -m elf_s390" ++ ;; ++ sparc64-*linux*) ++ LD="${LD-ld} -m elf32_sparc" ++ ;; ++ esac ++ ;; ++ *64-bit*) ++ case $host in ++ x86_64-*linux*) ++ LD="${LD-ld} -m elf_x86_64" ++ ;; ++ ppc*-*linux*|powerpc*-*linux*) ++ LD="${LD-ld} -m elf64ppc" ++ ;; ++ s390*-*linux*) ++ LD="${LD-ld} -m elf64_s390" ++ ;; ++ sparc*-*linux*) ++ LD="${LD-ld} -m elf64_sparc" ++ ;; ++ esac ++ ;; ++ esac ++ fi ++ rm -rf conftest* ++ ;; ++ ++*-*-sco3.2v5*) ++ # On SCO OpenServer 5, we need -belf to get full-featured binaries. ++ SAVE_CFLAGS="$CFLAGS" ++ CFLAGS="$CFLAGS -belf" ++ echo "$as_me:$LINENO: checking whether the C compiler needs -belf" >&5 ++echo $ECHO_N "checking whether the C compiler needs -belf... $ECHO_C" >&6 ++if test "${lt_cv_cc_needs_belf+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ ++ ++ ac_ext=c ++ac_cpp='$CPP $CPPFLAGS' ++ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ++ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ++ac_compiler_gnu=$ac_cv_c_compiler_gnu ++ ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++/* confdefs.h. */ ++_ACEOF ++cat confdefs.h >>conftest.$ac_ext ++cat >>conftest.$ac_ext <<_ACEOF ++/* end confdefs.h. */ ++ ++int ++main () ++{ ++ ++ ; ++ return 0; ++} ++_ACEOF ++rm -f conftest.$ac_objext conftest$ac_exeext ++if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 ++ (eval $ac_link) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && ++ { ac_try='test -s conftest$ac_exeext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ lt_cv_cc_needs_belf=yes ++else ++ echo "$as_me: failed program was:" >&5 ++sed 's/^/| /' conftest.$ac_ext >&5 ++ ++lt_cv_cc_needs_belf=no ++fi ++rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext ++ ac_ext=c ++ac_cpp='$CPP $CPPFLAGS' ++ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ++ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ++ac_compiler_gnu=$ac_cv_c_compiler_gnu ++ ++fi ++echo "$as_me:$LINENO: result: $lt_cv_cc_needs_belf" >&5 ++echo "${ECHO_T}$lt_cv_cc_needs_belf" >&6 ++ if test x"$lt_cv_cc_needs_belf" != x"yes"; then ++ # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf ++ CFLAGS="$SAVE_CFLAGS" ++ fi ++ ;; ++ ++ ++esac ++ ++ ++# Save cache, so that ltconfig can load it ++cat >confcache <<\_ACEOF ++# This file is a shell script that caches the results of configure ++# tests run on this system so they can be shared between configure ++# scripts and configure runs, see configure's option --config-cache. ++# It is not useful on other systems. If it contains results you don't ++# want to keep, you may remove or edit it. ++# ++# config.status only pays attention to the cache file if you give it ++# the --recheck option to rerun configure. ++# ++# `ac_cv_env_foo' variables (set or unset) will be overridden when ++# loading this file, other *unset* `ac_cv_foo' will be assigned the ++# following values. ++ ++_ACEOF ++ ++# The following way of writing the cache mishandles newlines in values, ++# but we know of no workaround that is simple, portable, and efficient. ++# So, don't put newlines in cache variables' values. ++# Ultrix sh set writes to stderr and can't be redirected directly, ++# and sets the high bit in the cache file unless we assign to the vars. ++{ ++ (set) 2>&1 | ++ case `(ac_space=' '; set | grep ac_space) 2>&1` in ++ *ac_space=\ *) ++ # `set' does not quote correctly, so add quotes (double-quote ++ # substitution turns \\\\ into \\, and sed turns \\ into \). ++ sed -n \ ++ "s/'/'\\\\''/g; ++ s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" ++ ;; ++ *) ++ # `set' quotes correctly as required by POSIX, so do not add quotes. ++ sed -n \ ++ "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p" ++ ;; ++ esac; ++} | ++ sed ' ++ t clear ++ : clear ++ s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/ ++ t end ++ /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/ ++ : end' >>confcache ++if diff $cache_file confcache >/dev/null 2>&1; then :; else ++ if test -w $cache_file; then ++ test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file" ++ cat confcache >$cache_file ++ else ++ echo "not updating unwritable cache $cache_file" ++ fi ++fi ++rm -f confcache ++ ++# Actually configure libtool. ac_aux_dir is where install-sh is found. ++AR="$AR" LTCC="$CC" CC="$CC" CFLAGS="$CFLAGS" CPPFLAGS="$CPPFLAGS" \ ++MAGIC_CMD="$MAGIC_CMD" LD="$LD" LDFLAGS="$LDFLAGS" LIBS="$LIBS" \ ++LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" STRIP="$STRIP" \ ++AS="$AS" DLLTOOL="$DLLTOOL" OBJDUMP="$OBJDUMP" \ ++objext="$OBJEXT" exeext="$EXEEXT" reload_flag="$reload_flag" \ ++deplibs_check_method="$deplibs_check_method" file_magic_cmd="$file_magic_cmd" \ ++${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig --no-reexec \ ++$libtool_flags --no-verify --build="$build" $ac_aux_dir/ltmain.sh $host \ ++|| { { echo "$as_me:$LINENO: error: libtool configure failed" >&5 ++echo "$as_me: error: libtool configure failed" >&2;} ++ { (exit 1); exit 1; }; } ++ ++# Reload cache, that may have been modified by ltconfig ++if test -r "$cache_file"; then ++ # Some versions of bash will fail to source /dev/null (special ++ # files actually), so we avoid doing that. ++ if test -f "$cache_file"; then ++ { echo "$as_me:$LINENO: loading cache $cache_file" >&5 ++echo "$as_me: loading cache $cache_file" >&6;} ++ case $cache_file in ++ [\\/]* | ?:[\\/]* ) . $cache_file;; ++ *) . ./$cache_file;; ++ esac ++ fi ++else ++ { echo "$as_me:$LINENO: creating cache $cache_file" >&5 ++echo "$as_me: creating cache $cache_file" >&6;} ++ >$cache_file ++fi ++ ++ ++# This can be used to rebuild libtool when needed ++LIBTOOL_DEPS="$ac_aux_dir/ltconfig $ac_aux_dir/ltmain.sh $ac_aux_dir/ltcf-c.sh" ++ ++# Always use our own libtool. ++LIBTOOL='$(SHELL) $(top_builddir)/libtool' ++ ++# Redirect the config.log output again, so that the ltconfig log is not ++# clobbered by the next message. ++exec 5>>./config.log ++ ++ac_ext=cc ++ac_cpp='$CXXCPP $CPPFLAGS' ++ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' ++ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ++ac_compiler_gnu=$ac_cv_cxx_compiler_gnu ++echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5 ++echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6 ++if test -z "$CXXCPP"; then ++ if test "${ac_cv_prog_CXXCPP+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ # Double quotes because CXXCPP needs to be expanded ++ for CXXCPP in "$CXX -E" "/lib/cpp" ++ do ++ ac_preproc_ok=false ++for ac_cxx_preproc_warn_flag in '' yes ++do ++ # Use a header file that comes with gcc, so configuring glibc ++ # with a fresh cross-compiler works. ++ # Prefer to if __STDC__ is defined, since ++ # exists even on freestanding compilers. ++ # On the NeXT, cc -E runs the code through the compiler's parser, ++ # not just through cpp. "Syntax error" is here to catch this case. ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++/* confdefs.h. */ ++_ACEOF ++cat confdefs.h >>conftest.$ac_ext ++cat >>conftest.$ac_ext <<_ACEOF ++/* end confdefs.h. */ ++@%:@ifdef __STDC__ ++@%:@ include ++@%:@else ++@%:@ include ++@%:@endif ++ Syntax error ++_ACEOF ++if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 ++ (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 ++ ac_status=$? ++ grep -v '^ *+' conftest.er1 >conftest.err ++ rm -f conftest.er1 ++ cat conftest.err >&5 ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } >/dev/null; then ++ if test -s conftest.err; then ++ ac_cpp_err=$ac_cxx_preproc_warn_flag ++ else ++ ac_cpp_err= ++ fi ++else ++ ac_cpp_err=yes ++fi ++if test -z "$ac_cpp_err"; then ++ : ++else ++ echo "$as_me: failed program was:" >&5 ++sed 's/^/| /' conftest.$ac_ext >&5 ++ ++ # Broken: fails on valid input. ++continue ++fi ++rm -f conftest.err conftest.$ac_ext ++ ++ # OK, works on sane cases. Now check whether non-existent headers ++ # can be detected and how. ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++/* confdefs.h. */ ++_ACEOF ++cat confdefs.h >>conftest.$ac_ext ++cat >>conftest.$ac_ext <<_ACEOF ++/* end confdefs.h. */ ++@%:@include ++_ACEOF ++if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 ++ (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 ++ ac_status=$? ++ grep -v '^ *+' conftest.er1 >conftest.err ++ rm -f conftest.er1 ++ cat conftest.err >&5 ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } >/dev/null; then ++ if test -s conftest.err; then ++ ac_cpp_err=$ac_cxx_preproc_warn_flag ++ else ++ ac_cpp_err= ++ fi ++else ++ ac_cpp_err=yes ++fi ++if test -z "$ac_cpp_err"; then ++ # Broken: success on invalid input. ++continue ++else ++ echo "$as_me: failed program was:" >&5 ++sed 's/^/| /' conftest.$ac_ext >&5 ++ ++ # Passes both tests. ++ac_preproc_ok=: ++break ++fi ++rm -f conftest.err conftest.$ac_ext ++ ++done ++# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. ++rm -f conftest.err conftest.$ac_ext ++if $ac_preproc_ok; then ++ break ++fi ++ ++ done ++ ac_cv_prog_CXXCPP=$CXXCPP ++ ++fi ++ CXXCPP=$ac_cv_prog_CXXCPP ++else ++ ac_cv_prog_CXXCPP=$CXXCPP ++fi ++echo "$as_me:$LINENO: result: $CXXCPP" >&5 ++echo "${ECHO_T}$CXXCPP" >&6 ++ac_preproc_ok=false ++for ac_cxx_preproc_warn_flag in '' yes ++do ++ # Use a header file that comes with gcc, so configuring glibc ++ # with a fresh cross-compiler works. ++ # Prefer to if __STDC__ is defined, since ++ # exists even on freestanding compilers. ++ # On the NeXT, cc -E runs the code through the compiler's parser, ++ # not just through cpp. "Syntax error" is here to catch this case. ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++/* confdefs.h. */ ++_ACEOF ++cat confdefs.h >>conftest.$ac_ext ++cat >>conftest.$ac_ext <<_ACEOF ++/* end confdefs.h. */ ++@%:@ifdef __STDC__ ++@%:@ include ++@%:@else ++@%:@ include ++@%:@endif ++ Syntax error ++_ACEOF ++if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 ++ (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 ++ ac_status=$? ++ grep -v '^ *+' conftest.er1 >conftest.err ++ rm -f conftest.er1 ++ cat conftest.err >&5 ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } >/dev/null; then ++ if test -s conftest.err; then ++ ac_cpp_err=$ac_cxx_preproc_warn_flag ++ else ++ ac_cpp_err= ++ fi ++else ++ ac_cpp_err=yes ++fi ++if test -z "$ac_cpp_err"; then ++ : ++else ++ echo "$as_me: failed program was:" >&5 ++sed 's/^/| /' conftest.$ac_ext >&5 ++ ++ # Broken: fails on valid input. ++continue ++fi ++rm -f conftest.err conftest.$ac_ext ++ ++ # OK, works on sane cases. Now check whether non-existent headers ++ # can be detected and how. ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++/* confdefs.h. */ ++_ACEOF ++cat confdefs.h >>conftest.$ac_ext ++cat >>conftest.$ac_ext <<_ACEOF ++/* end confdefs.h. */ ++@%:@include ++_ACEOF ++if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 ++ (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 ++ ac_status=$? ++ grep -v '^ *+' conftest.er1 >conftest.err ++ rm -f conftest.er1 ++ cat conftest.err >&5 ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } >/dev/null; then ++ if test -s conftest.err; then ++ ac_cpp_err=$ac_cxx_preproc_warn_flag ++ else ++ ac_cpp_err= ++ fi ++else ++ ac_cpp_err=yes ++fi ++if test -z "$ac_cpp_err"; then ++ # Broken: success on invalid input. ++continue ++else ++ echo "$as_me: failed program was:" >&5 ++sed 's/^/| /' conftest.$ac_ext >&5 ++ ++ # Passes both tests. ++ac_preproc_ok=: ++break ++fi ++rm -f conftest.err conftest.$ac_ext ++ ++done ++# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. ++rm -f conftest.err conftest.$ac_ext ++if $ac_preproc_ok; then ++ : ++else ++ { { echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check ++See \`config.log' for more details." >&5 ++echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check ++See \`config.log' for more details." >&2;} ++ { (exit 1); exit 1; }; } ++fi ++ ++ac_ext=c ++ac_cpp='$CPP $CPPFLAGS' ++ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ++ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ++ac_compiler_gnu=$ac_cv_c_compiler_gnu ++ ++ ++ ++LIBTOOL_DEPS=$LIBTOOL_DEPS" $ac_aux_dir/ltcf-cxx.sh" ++lt_save_CC="$CC" ++lt_save_CFLAGS="$CFLAGS" ++AR="$AR" LTCC="$CC" CC="$CXX" CXX="$CXX" CFLAGS="$CXXFLAGS" CPPFLAGS="$CPPFLAGS" \ ++MAGIC_CMD="$MAGIC_CMD" LD="$LD" LDFLAGS="$LDFLAGS" LIBS="$LIBS" \ ++LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" STRIP="$STRIP" \ ++AS="$AS" DLLTOOL="$DLLTOOL" OBJDUMP="$OBJDUMP" \ ++objext="$OBJEXT" exeext="$EXEEXT" reload_flag="$reload_flag" \ ++deplibs_check_method="$deplibs_check_method" \ ++file_magic_cmd="$file_magic_cmd" \ ++${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig -o libtool $libtool_flags \ ++--build="$build" --add-tag=CXX $ac_aux_dir/ltcf-cxx.sh $host \ ++|| { { echo "$as_me:$LINENO: error: libtool tag configuration failed" >&5 ++echo "$as_me: error: libtool tag configuration failed" >&2;} ++ { (exit 1); exit 1; }; } ++CC="$lt_save_CC" ++CFLAGS="$lt_save_CFLAGS" ++ ++# Redirect the config.log output again, so that the ltconfig log is not ++# clobbered by the next message. ++exec 5>>./config.log ++ ++ ++ ++ ++ ++ ++ ++ ++# Check whether --with-target-subdir or --without-target-subdir was given. ++if test "${with_target_subdir+set}" = set; then ++ withval="$with_target_subdir" ++ ++fi; ++ ++# Check whether --with-cross-host or --without-cross-host was given. ++if test "${with_cross_host+set}" = set; then ++ withval="$with_cross_host" ++ ++fi; ++ ++echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5 ++echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6 ++ # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given. ++if test "${enable_maintainer_mode+set}" = set; then ++ enableval="$enable_maintainer_mode" ++ USE_MAINTAINER_MODE=$enableval ++else ++ USE_MAINTAINER_MODE=no ++fi; ++ echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5 ++echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6 ++ ++ ++if test $USE_MAINTAINER_MODE = yes; then ++ MAINTAINER_MODE_TRUE= ++ MAINTAINER_MODE_FALSE='#' ++else ++ MAINTAINER_MODE_TRUE='#' ++ MAINTAINER_MODE_FALSE= ++fi ++ MAINT=$MAINTAINER_MODE_TRUE ++ ++ ++# automake wants to see AC_EXEEXT. But we don't need it. And having ++# it is actually a problem, because the compiler we're passed can't ++# necessarily do a full link. So we fool automake here. ++if false; then ++ # autoconf 2.50 runs AC_EXEEXT by default, and the macro expands ++ # to nothing, so nothing would remain between `then' and `fi' if it ++ # were not for the `:' below. ++ : ++ ++fi ++ ++echo "$as_me:$LINENO: checking for thread model used by GCC" >&5 ++echo $ECHO_N "checking for thread model used by GCC... $ECHO_C" >&6 ++THREADS=`$CC -v 2>&1 | sed -n 's/^Thread model: //p'` ++if test -z "$THREADS"; then ++ THREADS=no ++fi ++echo "$as_me:$LINENO: result: $THREADS" >&5 ++echo "${ECHO_T}$THREADS" >&6 ++ ++# Check whether --enable-parallel-mark or --disable-parallel-mark was given. ++if test "${enable_parallel_mark+set}" = set; then ++ enableval="$enable_parallel_mark" ++ case "$THREADS" in ++ no | none | single) ++ { { echo "$as_me:$LINENO: error: Parallel mark requires --enable-threads=x spec" >&5 ++echo "$as_me: error: Parallel mark requires --enable-threads=x spec" >&2;} ++ { (exit 1); exit 1; }; } ++ ;; ++ esac ++ ++fi; ++ ++INCLUDES=-I${srcdir}/include ++THREADLIBS= ++case "$THREADS" in ++ no | none | single) ++ THREADS=none ++ ;; ++ posix | pthreads) ++ THREADS=posix ++ THREADLIBS=-lpthread ++ case "$host" in ++ x86-*-linux* | ia64-*-linux* | i586-*-linux* | i686-*-linux* | x86_64-*-linux* ) ++ cat >>confdefs.h <<\_ACEOF ++@%:@define GC_LINUX_THREADS 1 ++_ACEOF ++ ++ cat >>confdefs.h <<\_ACEOF ++@%:@define _REENTRANT 1 ++_ACEOF ++ ++ if test "${enable_parallel_mark}"; then ++ cat >>confdefs.h <<\_ACEOF ++@%:@define PARALLEL_MARK 1 ++_ACEOF ++ ++ fi ++ cat >>confdefs.h <<\_ACEOF ++@%:@define THREAD_LOCAL_ALLOC 1 ++_ACEOF ++ ++ ;; ++ *-*-linux*) ++ cat >>confdefs.h <<\_ACEOF ++@%:@define GC_LINUX_THREADS 1 ++_ACEOF ++ ++ cat >>confdefs.h <<\_ACEOF ++@%:@define _REENTRANT 1 ++_ACEOF ++ ++ ;; ++ *-*-hpux*) ++ { echo "$as_me:$LINENO: WARNING: \"Only HP/UX 11 threads are supported.\"" >&5 ++echo "$as_me: WARNING: \"Only HP/UX 11 threads are supported.\"" >&2;} ++ cat >>confdefs.h <<\_ACEOF ++@%:@define GC_HPUX_THREADS 1 ++_ACEOF ++ ++ cat >>confdefs.h <<\_ACEOF ++@%:@define _POSIX_C_SOURCE 199506L ++_ACEOF ++ ++ if test "${enable_parallel_mark}" = yes; then ++ cat >>confdefs.h <<\_ACEOF ++@%:@define PARALLEL_MARK 1 ++_ACEOF ++ ++ fi ++ cat >>confdefs.h <<\_ACEOF ++@%:@define THREAD_LOCAL_ALLOC 1 ++_ACEOF ++ ++ THREADLIBS="-lpthread -lrt" ++ ;; ++ *-*-freebsd*) ++ { echo "$as_me:$LINENO: WARNING: \"FreeBSD does not yet fully support threads with Boehm GC.\"" >&5 ++echo "$as_me: WARNING: \"FreeBSD does not yet fully support threads with Boehm GC.\"" >&2;} ++ cat >>confdefs.h <<\_ACEOF ++@%:@define GC_FREEBSD_THREADS 1 ++_ACEOF ++ ++ INCLUDES="$INCLUDES -pthread" ++ THREADLIBS=-pthread ++ ;; ++ *-*-solaris*) ++ cat >>confdefs.h <<\_ACEOF ++@%:@define GC_SOLARIS_THREADS 1 ++_ACEOF ++ ++ cat >>confdefs.h <<\_ACEOF ++@%:@define GC_SOLARIS_PTHREADS 1 ++_ACEOF ++ ++ ;; ++ *-*-irix*) ++ cat >>confdefs.h <<\_ACEOF ++@%:@define GC_IRIX_THREADS 1 ++_ACEOF ++ ++ ;; ++ *-*-cygwin*) ++ THREADLIBS= ++ ;; ++ esac ++ ;; ++ *-*-darwin*) ++ cat >>confdefs.h <<\_ACEOF ++@%:@define GC_DARWIN_THREADS 1 ++_ACEOF ++ ++ cat >>confdefs.h <<\_ACEOF ++@%:@define THREAD_LOCAL_ALLOC 1 ++_ACEOF ++ ++ if test "${enable_parallel_mark}" = yes; then ++ cat >>confdefs.h <<\_ACEOF ++@%:@define PARALLEL_MARK 1 ++_ACEOF ++ ++ fi ++ ;; ++ win32) ++ cat >>confdefs.h <<\_ACEOF ++@%:@define GC_WIN32_THREADS 1 ++_ACEOF ++ ++ cat >>confdefs.h <<\_ACEOF ++@%:@define NO_GETENV 1 ++_ACEOF ++ ++ ;; ++ decosf1 | irix | mach | os2 | solaris | dce | vxworks) ++ { { echo "$as_me:$LINENO: error: thread package $THREADS not yet supported" >&5 ++echo "$as_me: error: thread package $THREADS not yet supported" >&2;} ++ { (exit 1); exit 1; }; } ++ ;; ++ *) ++ { { echo "$as_me:$LINENO: error: $THREADS is an unknown thread package" >&5 ++echo "$as_me: error: $THREADS is an unknown thread package" >&2;} ++ { (exit 1); exit 1; }; } ++ ;; ++esac ++ ++ ++case "$host" in ++ powerpc-*-darwin*) ++ powerpc_darwin=true ++ ;; ++esac ++ ++ ++if test x$powerpc_darwin = xtrue; then ++ POWERPC_DARWIN_TRUE= ++ POWERPC_DARWIN_FALSE='#' ++else ++ POWERPC_DARWIN_TRUE='#' ++ POWERPC_DARWIN_FALSE= ++fi ++ ++# We never want libdl on darwin. It is a fake libdl that just ends up making ++# dyld calls anyway ++case "$host" in ++ *-*-darwin*) ;; ++ *) ++ echo "$as_me:$LINENO: checking for dlopen in -ldl" >&5 ++echo $ECHO_N "checking for dlopen in -ldl... $ECHO_C" >&6 ++if test "${ac_cv_lib_dl_dlopen+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ ac_check_lib_save_LIBS=$LIBS ++LIBS="-ldl $LIBS" ++cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++/* confdefs.h. */ ++_ACEOF ++cat confdefs.h >>conftest.$ac_ext ++cat >>conftest.$ac_ext <<_ACEOF ++/* end confdefs.h. */ ++ ++/* Override any gcc2 internal prototype to avoid an error. */ ++#ifdef __cplusplus ++extern "C" ++#endif ++/* We use char because int might match the return type of a gcc2 ++ builtin and then its argument prototype would still apply. */ ++char dlopen (); ++int ++main () ++{ ++dlopen (); ++ ; ++ return 0; ++} ++_ACEOF ++rm -f conftest.$ac_objext conftest$ac_exeext ++if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 ++ (eval $ac_link) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && ++ { ac_try='test -s conftest$ac_exeext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ ac_cv_lib_dl_dlopen=yes ++else ++ echo "$as_me: failed program was:" >&5 ++sed 's/^/| /' conftest.$ac_ext >&5 ++ ++ac_cv_lib_dl_dlopen=no ++fi ++rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext ++LIBS=$ac_check_lib_save_LIBS ++fi ++echo "$as_me:$LINENO: result: $ac_cv_lib_dl_dlopen" >&5 ++echo "${ECHO_T}$ac_cv_lib_dl_dlopen" >&6 ++if test $ac_cv_lib_dl_dlopen = yes; then ++ EXTRA_TEST_LIBS="$EXTRA_TEST_LIBS -ldl" ++fi ++ ++ ;; ++esac ++ ++ ++ ++target_all=libgcjgc.la ++ ++ ++ ++TARGET_ECOS="no" ++ ++# Check whether --with-ecos or --without-ecos was given. ++if test "${with_ecos+set}" = set; then ++ withval="$with_ecos" ++ TARGET_ECOS="$with_ecos" ++ ++fi; ++ ++addobjs= ++CXXINCLUDES= ++case "$TARGET_ECOS" in ++ no) ++ ;; ++ *) ++ cat >>confdefs.h <<\_ACEOF ++@%:@define ECOS 1 ++_ACEOF ++ ++ CXXINCLUDES="-I${TARGET_ECOS}/include" ++ addobjs="$addobjs ecos.lo" ++ ;; ++esac ++ ++ ++ ++ ++ ++machdep= ++case "$host" in ++ alpha*-*-openbsd*) ++ machdep="alpha_mach_dep.lo" ++ if test x"${ac_cv_lib_dl_dlopen}" != xyes ; then ++ { echo "$as_me:$LINENO: WARNING: OpenBSD/Alpha without dlopen(). Shared library support is disabled" >&5 ++echo "$as_me: WARNING: OpenBSD/Alpha without dlopen(). Shared library support is disabled" >&2;} ++ # Check whether --enable-shared or --disable-shared was given. ++if test "${enable_shared+set}" = set; then ++ enableval="$enable_shared" ++ p=${PACKAGE-default} ++case $enableval in ++yes) enable_shared=yes ;; ++no) enable_shared=no ;; ++*) ++ enable_shared=no ++ # Look at the argument we got. We use all the common list separators. ++ IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:," ++ for pkg in $enableval; do ++ if test "X$pkg" = "X$p"; then ++ enable_shared=yes ++ fi ++ done ++ IFS="$ac_save_ifs" ++ ;; ++esac ++else ++ enable_shared=no ++fi; ++ fi ++ ;; ++ alpha*-*-*) ++ machdep="alpha_mach_dep.lo" ++ ;; ++ i?86-*-solaris2.[89]*) ++ cat >>confdefs.h <<\_ACEOF ++@%:@define SOLARIS25_PROC_VDB_BUG_FIXED 1 ++_ACEOF ++ ++ ;; ++ mipstx39-*-elf*) ++ machdep="mips_ultrix_mach_dep.lo" ++ cat >>confdefs.h <<\_ACEOF ++@%:@define STACKBASE __stackbase ++_ACEOF ++ ++ cat >>confdefs.h <<\_ACEOF ++@%:@define DATASTART_IS_ETEXT 1 ++_ACEOF ++ ++ ;; ++ mips-dec-ultrix*) ++ machdep="mips_ultrix_mach-dep.lo" ++ ;; ++ mips*-*-linux*) ++ ;; ++ mips-*-*) ++ machdep="mips_sgi_mach_dep.lo" ++ cat >>confdefs.h <<\_ACEOF ++@%:@define NO_EXECUTE_PERMISSION 1 ++_ACEOF ++ ++ ;; ++ sparc-sun-solaris2.3*) ++ machdep="sparc_mach_dep.lo" ++ cat >>confdefs.h <<\_ACEOF ++@%:@define SUNOS53_SHARED_LIB 1 ++_ACEOF ++ ++ ;; ++ sparc-sun-solaris2.*) ++ machdep="sparc_mach_dep.lo" ++ ;; ++ ia64-*-*) ++ machdep="mach_dep.lo ia64_save_regs_in_stack.lo" ++ ;; ++esac ++if test x"$machdep" = x; then ++ machdep="mach_dep.lo" ++fi ++addobjs="$addobjs $machdep" ++ ++ ++case "$host" in ++ sparc-sun-solaris2*) ++ if test "$GCC" = yes; then ++ new_CFLAGS= ++ for i in $CFLAGS; do ++ case "$i" in ++ -O*) ++ ;; ++ *) ++ new_CFLAGS="$new_CFLAGS $i" ++ ;; ++ esac ++ done ++ CFLAGS="$new_CFLAGS" ++ fi ++ ;; ++esac ++ ++MY_CFLAGS="$CFLAGS" ++ ++ ++cat >>confdefs.h <<\_ACEOF ++@%:@define SILENT 1 ++_ACEOF ++ ++cat >>confdefs.h <<\_ACEOF ++@%:@define NO_SIGNALS 1 ++_ACEOF ++ ++cat >>confdefs.h <<\_ACEOF ++@%:@define NO_EXECUTE_PERMISSION 1 ++_ACEOF ++ ++cat >>confdefs.h <<\_ACEOF ++@%:@define ALL_INTERIOR_POINTERS 1 ++_ACEOF ++ ++ ++cat >>confdefs.h <<\_ACEOF ++@%:@define JAVA_FINALIZATION 1 ++_ACEOF ++ ++cat >>confdefs.h <<\_ACEOF ++@%:@define GC_GCJ_SUPPORT 1 ++_ACEOF ++ ++cat >>confdefs.h <<\_ACEOF ++@%:@define ATOMIC_UNCOLLECTABLE 1 ++_ACEOF ++ ++ ++if test -n "${with_cross_host}"; then ++ cat >>confdefs.h <<\_ACEOF ++@%:@define NO_SIGSET 1 ++_ACEOF ++ ++ cat >>confdefs.h <<\_ACEOF ++@%:@define NO_DEBUGGING 1 ++_ACEOF ++ ++fi ++ ++# Check whether --enable-full-debug or --disable-full-debug was given. ++if test "${enable_full_debug+set}" = set; then ++ enableval="$enable_full_debug" ++ if test "$enable_full_debug" = "yes"; then ++ { echo "$as_me:$LINENO: WARNING: \"Must define GC_DEBUG and use debug alloc. in clients.\"" >&5 ++echo "$as_me: WARNING: \"Must define GC_DEBUG and use debug alloc. in clients.\"" >&2;} ++ cat >>confdefs.h <<\_ACEOF ++@%:@define KEEP_BACK_PTRS 1 ++_ACEOF ++ ++ cat >>confdefs.h <<\_ACEOF ++@%:@define DBG_HDRS_ALL 1 ++_ACEOF ++ ++ case $host in ++ ia64-*-linux* ) ++ cat >>confdefs.h <<\_ACEOF ++@%:@define MAKE_BACK_GRAPH 1 ++_ACEOF ++ ++ ;; ++ x86-*-linux* | i586-*-linux* | i686-*-linux* | x86_64-*-linux* ) ++ cat >>confdefs.h <<\_ACEOF ++@%:@define MAKE_BACK_GRAPH 1 ++_ACEOF ++ ++ { echo "$as_me:$LINENO: WARNING: \"Client must not use -fomit-frame-pointer.\"" >&5 ++echo "$as_me: WARNING: \"Client must not use -fomit-frame-pointer.\"" >&2;} ++ cat >>confdefs.h <<\_ACEOF ++@%:@define SAVE_CALL_COUNT 8 ++_ACEOF ++ ++ ;; ++ esac ++ fi ++fi; ++ ++ ++ ++if test -z "$with_cross_host"; then ++ USE_LIBDIR_TRUE= ++ USE_LIBDIR_FALSE='#' ++else ++ USE_LIBDIR_TRUE='#' ++ USE_LIBDIR_FALSE= ++fi ++ ++if test "${multilib}" = "yes"; then ++ multilib_arg="--enable-multilib" ++else ++ multilib_arg= ++fi ++ ++ ac_config_files="$ac_config_files Makefile include/Makefile" ++ ac_config_commands="$ac_config_commands default" ++cat >confcache <<\_ACEOF ++# This file is a shell script that caches the results of configure ++# tests run on this system so they can be shared between configure ++# scripts and configure runs, see configure's option --config-cache. ++# It is not useful on other systems. If it contains results you don't ++# want to keep, you may remove or edit it. ++# ++# config.status only pays attention to the cache file if you give it ++# the --recheck option to rerun configure. ++# ++# `ac_cv_env_foo' variables (set or unset) will be overridden when ++# loading this file, other *unset* `ac_cv_foo' will be assigned the ++# following values. ++ ++_ACEOF ++ ++# The following way of writing the cache mishandles newlines in values, ++# but we know of no workaround that is simple, portable, and efficient. ++# So, don't put newlines in cache variables' values. ++# Ultrix sh set writes to stderr and can't be redirected directly, ++# and sets the high bit in the cache file unless we assign to the vars. ++{ ++ (set) 2>&1 | ++ case `(ac_space=' '; set | grep ac_space) 2>&1` in ++ *ac_space=\ *) ++ # `set' does not quote correctly, so add quotes (double-quote ++ # substitution turns \\\\ into \\, and sed turns \\ into \). ++ sed -n \ ++ "s/'/'\\\\''/g; ++ s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" ++ ;; ++ *) ++ # `set' quotes correctly as required by POSIX, so do not add quotes. ++ sed -n \ ++ "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p" ++ ;; ++ esac; ++} | ++ sed ' ++ t clear ++ : clear ++ s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/ ++ t end ++ /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/ ++ : end' >>confcache ++if diff $cache_file confcache >/dev/null 2>&1; then :; else ++ if test -w $cache_file; then ++ test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file" ++ cat confcache >$cache_file ++ else ++ echo "not updating unwritable cache $cache_file" ++ fi ++fi ++rm -f confcache ++ ++test "x$prefix" = xNONE && prefix=$ac_default_prefix ++# Let make expand exec_prefix. ++test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' ++ ++# VPATH may cause trouble with some makes, so we remove $(srcdir), ++# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and ++# trailing colons and then remove the whole line if VPATH becomes empty ++# (actually we leave an empty line to preserve line numbers). ++if test "x$srcdir" = x.; then ++ ac_vpsub='/^[ ]*VPATH[ ]*=/{ ++s/:*\$(srcdir):*/:/; ++s/:*\${srcdir}:*/:/; ++s/:*@srcdir@:*/:/; ++s/^\([^=]*=[ ]*\):*/\1/; ++s/:*$//; ++s/^[^=]*=[ ]*$//; ++}' ++fi ++ ++# Transform confdefs.h into DEFS. ++# Protect against shell expansion while executing Makefile rules. ++# Protect against Makefile macro expansion. ++# ++# If the first sed substitution is executed (which looks for macros that ++# take arguments), then we branch to the quote section. Otherwise, ++# look for a macro that doesn't take arguments. ++cat >confdef2opt.sed <<\_ACEOF ++t clear ++: clear ++s,^[ ]*#[ ]*define[ ][ ]*\([^ (][^ (]*([^)]*)\)[ ]*\(.*\),-D\1=\2,g ++t quote ++s,^[ ]*#[ ]*define[ ][ ]*\([^ ][^ ]*\)[ ]*\(.*\),-D\1=\2,g ++t quote ++d ++: quote ++s,[ `~#$^&*(){}\\|;'"<>?],\\&,g ++s,\[,\\&,g ++s,\],\\&,g ++s,\$,$$,g ++p ++_ACEOF ++# We use echo to avoid assuming a particular line-breaking character. ++# The extra dot is to prevent the shell from consuming trailing ++# line-breaks from the sub-command output. A line-break within ++# single-quotes doesn't work because, if this script is created in a ++# platform that uses two characters for line-breaks (e.g., DOS), tr ++# would break. ++ac_LF_and_DOT=`echo; echo .` ++DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'` ++rm -f confdef2opt.sed ++ ++ ++ac_libobjs= ++ac_ltlibobjs= ++for ac_i in : $LIB@&t@OBJS; do test "x$ac_i" = x: && continue ++ # 1. Remove the extension, and $U if already installed. ++ ac_i=`echo "$ac_i" | ++ sed 's/\$U\././;s/\.o$//;s/\.obj$//'` ++ # 2. Add them. ++ ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext" ++ ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo' ++done ++LIB@&t@OBJS=$ac_libobjs ++ ++LTLIBOBJS=$ac_ltlibobjs ++ ++ ++ ++: ${CONFIG_STATUS=./config.status} ++ac_clean_files_save=$ac_clean_files ++ac_clean_files="$ac_clean_files $CONFIG_STATUS" ++{ echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5 ++echo "$as_me: creating $CONFIG_STATUS" >&6;} ++cat >$CONFIG_STATUS <<_ACEOF ++#! $SHELL ++# Generated by $as_me. ++# Run this file to recreate the current configuration. ++# Compiler output produced by configure, useful for debugging ++# configure, is in config.log if it exists. ++ ++debug=false ++ac_cs_recheck=false ++ac_cs_silent=false ++SHELL=\${CONFIG_SHELL-$SHELL} ++_ACEOF ++ ++cat >>$CONFIG_STATUS <<\_ACEOF ++## --------------------- ## ++## M4sh Initialization. ## ++## --------------------- ## ++ ++# Be Bourne compatible ++if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then ++ emulate sh ++ NULLCMD=: ++ # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which ++ # is contrary to our usage. Disable this feature. ++ alias -g '${1+"$@"}'='"$@"' ++elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then ++ set -o posix ++fi ++ ++# Support unset when possible. ++if (FOO=FOO; unset FOO) >/dev/null 2>&1; then ++ as_unset=unset ++else ++ as_unset=false ++fi ++ ++ ++# Work around bugs in pre-3.0 UWIN ksh. ++$as_unset ENV MAIL MAILPATH ++PS1='$ ' ++PS2='> ' ++PS4='+ ' ++ ++# NLS nuisances. ++for as_var in \ ++ LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \ ++ LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \ ++ LC_TELEPHONE LC_TIME ++do ++ if (set +x; test -n "`(eval $as_var=C; export $as_var) 2>&1`"); then ++ eval $as_var=C; export $as_var ++ else ++ $as_unset $as_var ++ fi ++done ++ ++# Required to use basename. ++if expr a : '\(a\)' >/dev/null 2>&1; then ++ as_expr=expr ++else ++ as_expr=false ++fi ++ ++if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then ++ as_basename=basename ++else ++ as_basename=false ++fi ++ ++ ++# Name of the executable. ++as_me=`$as_basename "$0" || ++$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ ++ X"$0" : 'X\(//\)$' \| \ ++ X"$0" : 'X\(/\)$' \| \ ++ . : '\(.\)' 2>/dev/null || ++echo X/"$0" | ++ sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; } ++ /^X\/\(\/\/\)$/{ s//\1/; q; } ++ /^X\/\(\/\).*/{ s//\1/; q; } ++ s/.*/./; q'` ++ ++ ++# PATH needs CR, and LINENO needs CR and PATH. ++# Avoid depending upon Character Ranges. ++as_cr_letters='abcdefghijklmnopqrstuvwxyz' ++as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' ++as_cr_Letters=$as_cr_letters$as_cr_LETTERS ++as_cr_digits='0123456789' ++as_cr_alnum=$as_cr_Letters$as_cr_digits ++ ++# The user is always right. ++if test "${PATH_SEPARATOR+set}" != set; then ++ echo "#! /bin/sh" >conf$$.sh ++ echo "exit 0" >>conf$$.sh ++ chmod +x conf$$.sh ++ if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then ++ PATH_SEPARATOR=';' ++ else ++ PATH_SEPARATOR=: ++ fi ++ rm -f conf$$.sh ++fi ++ ++ ++ as_lineno_1=$LINENO ++ as_lineno_2=$LINENO ++ as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null` ++ test "x$as_lineno_1" != "x$as_lineno_2" && ++ test "x$as_lineno_3" = "x$as_lineno_2" || { ++ # Find who we are. Look in the path if we contain no path at all ++ # relative or not. ++ case $0 in ++ *[\\/]* ) as_myself=$0 ;; ++ *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break ++done ++ ++ ;; ++ esac ++ # We did not find ourselves, most probably we were run as `sh COMMAND' ++ # in which case we are not to be found in the path. ++ if test "x$as_myself" = x; then ++ as_myself=$0 ++ fi ++ if test ! -f "$as_myself"; then ++ { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5 ++echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;} ++ { (exit 1); exit 1; }; } ++ fi ++ case $CONFIG_SHELL in ++ '') ++ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for as_base in sh bash ksh sh5; do ++ case $as_dir in ++ /*) ++ if ("$as_dir/$as_base" -c ' ++ as_lineno_1=$LINENO ++ as_lineno_2=$LINENO ++ as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null` ++ test "x$as_lineno_1" != "x$as_lineno_2" && ++ test "x$as_lineno_3" = "x$as_lineno_2" ') 2>/dev/null; then ++ $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; } ++ $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; } ++ CONFIG_SHELL=$as_dir/$as_base ++ export CONFIG_SHELL ++ exec "$CONFIG_SHELL" "$0" ${1+"$@"} ++ fi;; ++ esac ++ done ++done ++;; ++ esac ++ ++ # Create $as_me.lineno as a copy of $as_myself, but with $LINENO ++ # uniformly replaced by the line number. The first 'sed' inserts a ++ # line-number line before each line; the second 'sed' does the real ++ # work. The second script uses 'N' to pair each line-number line ++ # with the numbered line, and appends trailing '-' during ++ # substitution so that $LINENO is not a special case at line end. ++ # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the ++ # second 'sed' script. Blame Lee E. McMahon for sed's syntax. :-) ++ sed '=' <$as_myself | ++ sed ' ++ N ++ s,$,-, ++ : loop ++ s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3, ++ t loop ++ s,-$,, ++ s,^['$as_cr_digits']*\n,, ++ ' >$as_me.lineno && ++ chmod +x $as_me.lineno || ++ { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5 ++echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;} ++ { (exit 1); exit 1; }; } ++ ++ # Don't try to exec as it changes $[0], causing all sort of problems ++ # (the dirname of $[0] is not the place where we might find the ++ # original and so on. Autoconf is especially sensible to this). ++ . ./$as_me.lineno ++ # Exit status is that of the last command. ++ exit ++} ++ ++ ++case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in ++ *c*,-n*) ECHO_N= ECHO_C=' ++' ECHO_T=' ' ;; ++ *c*,* ) ECHO_N=-n ECHO_C= ECHO_T= ;; ++ *) ECHO_N= ECHO_C='\c' ECHO_T= ;; ++esac ++ ++if expr a : '\(a\)' >/dev/null 2>&1; then ++ as_expr=expr ++else ++ as_expr=false ++fi ++ ++rm -f conf$$ conf$$.exe conf$$.file ++echo >conf$$.file ++if ln -s conf$$.file conf$$ 2>/dev/null; then ++ # We could just check for DJGPP; but this test a) works b) is more generic ++ # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04). ++ if test -f conf$$.exe; then ++ # Don't use ln at all; we don't have any links ++ as_ln_s='cp -p' ++ else ++ as_ln_s='ln -s' ++ fi ++elif ln conf$$.file conf$$ 2>/dev/null; then ++ as_ln_s=ln ++else ++ as_ln_s='cp -p' ++fi ++rm -f conf$$ conf$$.exe conf$$.file ++ ++if mkdir -p . 2>/dev/null; then ++ as_mkdir_p=: ++else ++ as_mkdir_p=false ++fi ++ ++as_executable_p="test -f" ++ ++# Sed expression to map a string onto a valid CPP name. ++as_tr_cpp="sed y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g" ++ ++# Sed expression to map a string onto a valid variable name. ++as_tr_sh="sed y%*+%pp%;s%[^_$as_cr_alnum]%_%g" ++ ++ ++# IFS ++# We need space, tab and new line, in precisely that order. ++as_nl=' ++' ++IFS=" $as_nl" ++ ++# CDPATH. ++$as_unset CDPATH ++ ++exec 6>&1 ++ ++# Open the log real soon, to keep \$[0] and so on meaningful, and to ++# report actual input values of CONFIG_FILES etc. instead of their ++# values after options handling. Logging --version etc. is OK. ++exec 5>>config.log ++{ ++ echo ++ sed 'h;s/./-/g;s/^.../@%:@@%:@ /;s/...$/ @%:@@%:@/;p;x;p;x' <<_ASBOX ++@%:@@%:@ Running $as_me. @%:@@%:@ ++_ASBOX ++} >&5 ++cat >&5 <<_CSEOF ++ ++This file was extended by $as_me, which was ++generated by GNU Autoconf 2.57. Invocation command line was ++ ++ CONFIG_FILES = $CONFIG_FILES ++ CONFIG_HEADERS = $CONFIG_HEADERS ++ CONFIG_LINKS = $CONFIG_LINKS ++ CONFIG_COMMANDS = $CONFIG_COMMANDS ++ $ $0 $@ ++ ++_CSEOF ++echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5 ++echo >&5 ++_ACEOF ++ ++# Files that config.status was made for. ++if test -n "$ac_config_files"; then ++ echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS ++fi ++ ++if test -n "$ac_config_headers"; then ++ echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS ++fi ++ ++if test -n "$ac_config_links"; then ++ echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS ++fi ++ ++if test -n "$ac_config_commands"; then ++ echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS ++fi ++ ++cat >>$CONFIG_STATUS <<\_ACEOF ++ ++ac_cs_usage="\ ++\`$as_me' instantiates files from templates according to the ++current configuration. ++ ++Usage: $0 [OPTIONS] [FILE]... ++ ++ -h, --help print this help, then exit ++ -V, --version print version number, then exit ++ -q, --quiet do not print progress messages ++ -d, --debug don't remove temporary files ++ --recheck update $as_me by reconfiguring in the same conditions ++ --file=FILE[:TEMPLATE] ++ instantiate the configuration file FILE ++ ++Configuration files: ++$config_files ++ ++Configuration commands: ++$config_commands ++ ++Report bugs to ." ++_ACEOF ++ ++cat >>$CONFIG_STATUS <<_ACEOF ++ac_cs_version="\\ ++config.status ++configured by $0, generated by GNU Autoconf 2.57, ++ with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\" ++ ++Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001 ++Free Software Foundation, Inc. ++This config.status script is free software; the Free Software Foundation ++gives unlimited permission to copy, distribute and modify it." ++srcdir=$srcdir ++INSTALL="$INSTALL" ++_ACEOF ++ ++cat >>$CONFIG_STATUS <<\_ACEOF ++# If no file are specified by the user, then we need to provide default ++# value. By we need to know if files were specified by the user. ++ac_need_defaults=: ++while test $# != 0 ++do ++ case $1 in ++ --*=*) ++ ac_option=`expr "x$1" : 'x\([^=]*\)='` ++ ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'` ++ ac_shift=: ++ ;; ++ -*) ++ ac_option=$1 ++ ac_optarg=$2 ++ ac_shift=shift ++ ;; ++ *) # This is not an option, so the user has probably given explicit ++ # arguments. ++ ac_option=$1 ++ ac_need_defaults=false;; ++ esac ++ ++ case $ac_option in ++ # Handling of the options. ++_ACEOF ++cat >>$CONFIG_STATUS <<\_ACEOF ++ -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) ++ ac_cs_recheck=: ;; ++ --version | --vers* | -V ) ++ echo "$ac_cs_version"; exit 0 ;; ++ --he | --h) ++ # Conflict between --help and --header ++ { { echo "$as_me:$LINENO: error: ambiguous option: $1 ++Try \`$0 --help' for more information." >&5 ++echo "$as_me: error: ambiguous option: $1 ++Try \`$0 --help' for more information." >&2;} ++ { (exit 1); exit 1; }; };; ++ --help | --hel | -h ) ++ echo "$ac_cs_usage"; exit 0 ;; ++ --debug | --d* | -d ) ++ debug=: ;; ++ --file | --fil | --fi | --f ) ++ $ac_shift ++ CONFIG_FILES="$CONFIG_FILES $ac_optarg" ++ ac_need_defaults=false;; ++ --header | --heade | --head | --hea ) ++ $ac_shift ++ CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg" ++ ac_need_defaults=false;; ++ -q | -quiet | --quiet | --quie | --qui | --qu | --q \ ++ | -silent | --silent | --silen | --sile | --sil | --si | --s) ++ ac_cs_silent=: ;; ++ ++ # This is an error. ++ -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1 ++Try \`$0 --help' for more information." >&5 ++echo "$as_me: error: unrecognized option: $1 ++Try \`$0 --help' for more information." >&2;} ++ { (exit 1); exit 1; }; } ;; ++ ++ *) ac_config_targets="$ac_config_targets $1" ;; ++ ++ esac ++ shift ++done ++ ++ac_configure_extra_args= ++ ++if $ac_cs_silent; then ++ exec 6>/dev/null ++ ac_configure_extra_args="$ac_configure_extra_args --silent" ++fi ++ ++_ACEOF ++cat >>$CONFIG_STATUS <<_ACEOF ++if \$ac_cs_recheck; then ++ echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6 ++ exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion ++fi ++ ++_ACEOF ++ ++cat >>$CONFIG_STATUS <<_ACEOF ++# ++# INIT-COMMANDS section. ++# ++ ++srcdir=${srcdir} ++host=${host} ++target=${target} ++with_multisubdir=${with_multisubdir} ++ac_configure_args="${multilib_arg} ${ac_configure_args}" ++CONFIG_SHELL=${CONFIG_SHELL-/bin/sh} ++gc_basedir=${gc_basedir} ++CC="${CC}" ++DEFS="$DEFS" ++ ++ ++_ACEOF ++ ++ ++ ++cat >>$CONFIG_STATUS <<\_ACEOF ++for ac_config_target in $ac_config_targets ++do ++ case "$ac_config_target" in ++ # Handling of arguments. ++ "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;; ++ "include/Makefile" ) CONFIG_FILES="$CONFIG_FILES include/Makefile" ;; ++ "default" ) CONFIG_COMMANDS="$CONFIG_COMMANDS default" ;; ++ *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5 ++echo "$as_me: error: invalid argument: $ac_config_target" >&2;} ++ { (exit 1); exit 1; }; };; ++ esac ++done ++ ++# If the user did not use the arguments to specify the items to instantiate, ++# then the envvar interface is used. Set only those that are not. ++# We use the long form for the default assignment because of an extremely ++# bizarre bug on SunOS 4.1.3. ++if $ac_need_defaults; then ++ test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files ++ test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands ++fi ++ ++# Have a temporary directory for convenience. Make it in the build tree ++# simply because there is no reason to put it here, and in addition, ++# creating and moving files from /tmp can sometimes cause problems. ++# Create a temporary directory, and hook for its removal unless debugging. ++$debug || ++{ ++ trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0 ++ trap '{ (exit 1); exit 1; }' 1 2 13 15 ++} ++ ++# Create a (secure) tmp directory for tmp files. ++ ++{ ++ tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` && ++ test -n "$tmp" && test -d "$tmp" ++} || ++{ ++ tmp=./confstat$$-$RANDOM ++ (umask 077 && mkdir $tmp) ++} || ++{ ++ echo "$me: cannot create a temporary directory in ." >&2 ++ { (exit 1); exit 1; } ++} ++ ++_ACEOF ++ ++cat >>$CONFIG_STATUS <<_ACEOF ++ ++# ++# CONFIG_FILES section. ++# ++ ++# No need to generate the scripts if there are no CONFIG_FILES. ++# This happens for instance when ./config.status config.h ++if test -n "\$CONFIG_FILES"; then ++ # Protect against being on the right side of a sed subst in config.status. ++ sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g; ++ s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF ++s,@SHELL@,$SHELL,;t t ++s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t ++s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t ++s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t ++s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t ++s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t ++s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t ++s,@exec_prefix@,$exec_prefix,;t t ++s,@prefix@,$prefix,;t t ++s,@program_transform_name@,$program_transform_name,;t t ++s,@bindir@,$bindir,;t t ++s,@sbindir@,$sbindir,;t t ++s,@libexecdir@,$libexecdir,;t t ++s,@datadir@,$datadir,;t t ++s,@sysconfdir@,$sysconfdir,;t t ++s,@sharedstatedir@,$sharedstatedir,;t t ++s,@localstatedir@,$localstatedir,;t t ++s,@libdir@,$libdir,;t t ++s,@includedir@,$includedir,;t t ++s,@oldincludedir@,$oldincludedir,;t t ++s,@infodir@,$infodir,;t t ++s,@mandir@,$mandir,;t t ++s,@build_alias@,$build_alias,;t t ++s,@host_alias@,$host_alias,;t t ++s,@target_alias@,$target_alias,;t t ++s,@DEFS@,$DEFS,;t t ++s,@ECHO_C@,$ECHO_C,;t t ++s,@ECHO_N@,$ECHO_N,;t t ++s,@ECHO_T@,$ECHO_T,;t t ++s,@LIBS@,$LIBS,;t t ++s,@gc_basedir@,$gc_basedir,;t t ++s,@build@,$build,;t t ++s,@build_cpu@,$build_cpu,;t t ++s,@build_vendor@,$build_vendor,;t t ++s,@build_os@,$build_os,;t t ++s,@host@,$host,;t t ++s,@host_cpu@,$host_cpu,;t t ++s,@host_vendor@,$host_vendor,;t t ++s,@host_os@,$host_os,;t t ++s,@target@,$target,;t t ++s,@target_cpu@,$target_cpu,;t t ++s,@target_vendor@,$target_vendor,;t t ++s,@target_os@,$target_os,;t t ++s,@mkinstalldirs@,$mkinstalldirs,;t t ++s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t ++s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t ++s,@INSTALL_DATA@,$INSTALL_DATA,;t t ++s,@PACKAGE@,$PACKAGE,;t t ++s,@VERSION@,$VERSION,;t t ++s,@ACLOCAL@,$ACLOCAL,;t t ++s,@AUTOCONF@,$AUTOCONF,;t t ++s,@AUTOMAKE@,$AUTOMAKE,;t t ++s,@AUTOHEADER@,$AUTOHEADER,;t t ++s,@MAKEINFO@,$MAKEINFO,;t t ++s,@SET_MAKE@,$SET_MAKE,;t t ++s,@CC@,$CC,;t t ++s,@CXX@,$CXX,;t t ++s,@AS@,$AS,;t t ++s,@ac_ct_AS@,$ac_ct_AS,;t t ++s,@AR@,$AR,;t t ++s,@ac_ct_AR@,$ac_ct_AR,;t t ++s,@RANLIB@,$RANLIB,;t t ++s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t ++s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t ++s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t ++s,@MAINT@,$MAINT,;t t ++s,@GC_CFLAGS@,$GC_CFLAGS,;t t ++s,@LN_S@,$LN_S,;t t ++s,@STRIP@,$STRIP,;t t ++s,@ac_ct_STRIP@,$ac_ct_STRIP,;t t ++s,@LIBTOOL@,$LIBTOOL,;t t ++s,@CXXCPP@,$CXXCPP,;t t ++s,@CPPFLAGS@,$CPPFLAGS,;t t ++s,@THREADLIBS@,$THREADLIBS,;t t ++s,@POWERPC_DARWIN_TRUE@,$POWERPC_DARWIN_TRUE,;t t ++s,@POWERPC_DARWIN_FALSE@,$POWERPC_DARWIN_FALSE,;t t ++s,@EXTRA_TEST_LIBS@,$EXTRA_TEST_LIBS,;t t ++s,@target_all@,$target_all,;t t ++s,@INCLUDES@,$INCLUDES,;t t ++s,@CXXINCLUDES@,$CXXINCLUDES,;t t ++s,@addobjs@,$addobjs,;t t ++s,@MY_CFLAGS@,$MY_CFLAGS,;t t ++s,@USE_LIBDIR_TRUE@,$USE_LIBDIR_TRUE,;t t ++s,@USE_LIBDIR_FALSE@,$USE_LIBDIR_FALSE,;t t ++s,@LIB@&t@OBJS@,$LIB@&t@OBJS,;t t ++s,@LTLIBOBJS@,$LTLIBOBJS,;t t ++CEOF ++ ++_ACEOF ++ ++ cat >>$CONFIG_STATUS <<\_ACEOF ++ # Split the substitutions into bite-sized pieces for seds with ++ # small command number limits, like on Digital OSF/1 and HP-UX. ++ ac_max_sed_lines=48 ++ ac_sed_frag=1 # Number of current file. ++ ac_beg=1 # First line for current file. ++ ac_end=$ac_max_sed_lines # Line after last line for current file. ++ ac_more_lines=: ++ ac_sed_cmds= ++ while $ac_more_lines; do ++ if test $ac_beg -gt 1; then ++ sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag ++ else ++ sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag ++ fi ++ if test ! -s $tmp/subs.frag; then ++ ac_more_lines=false ++ else ++ # The purpose of the label and of the branching condition is to ++ # speed up the sed processing (if there are no `@' at all, there ++ # is no need to browse any of the substitutions). ++ # These are the two extra sed commands mentioned above. ++ (echo ':t ++ /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed ++ if test -z "$ac_sed_cmds"; then ++ ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed" ++ else ++ ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed" ++ fi ++ ac_sed_frag=`expr $ac_sed_frag + 1` ++ ac_beg=$ac_end ++ ac_end=`expr $ac_end + $ac_max_sed_lines` ++ fi ++ done ++ if test -z "$ac_sed_cmds"; then ++ ac_sed_cmds=cat ++ fi ++fi # test -n "$CONFIG_FILES" ++ ++_ACEOF ++cat >>$CONFIG_STATUS <<\_ACEOF ++for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue ++ # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in". ++ case $ac_file in ++ - | *:- | *:-:* ) # input from stdin ++ cat >$tmp/stdin ++ ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'` ++ ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;; ++ *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'` ++ ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;; ++ * ) ac_file_in=$ac_file.in ;; ++ esac ++ ++ # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories. ++ ac_dir=`(dirname "$ac_file") 2>/dev/null || ++$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ ++ X"$ac_file" : 'X\(//\)[^/]' \| \ ++ X"$ac_file" : 'X\(//\)$' \| \ ++ X"$ac_file" : 'X\(/\)' \| \ ++ . : '\(.\)' 2>/dev/null || ++echo X"$ac_file" | ++ sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; } ++ /^X\(\/\/\)[^/].*/{ s//\1/; q; } ++ /^X\(\/\/\)$/{ s//\1/; q; } ++ /^X\(\/\).*/{ s//\1/; q; } ++ s/.*/./; q'` ++ { if $as_mkdir_p; then ++ mkdir -p "$ac_dir" ++ else ++ as_dir="$ac_dir" ++ as_dirs= ++ while test ! -d "$as_dir"; do ++ as_dirs="$as_dir $as_dirs" ++ as_dir=`(dirname "$as_dir") 2>/dev/null || ++$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ ++ X"$as_dir" : 'X\(//\)[^/]' \| \ ++ X"$as_dir" : 'X\(//\)$' \| \ ++ X"$as_dir" : 'X\(/\)' \| \ ++ . : '\(.\)' 2>/dev/null || ++echo X"$as_dir" | ++ sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; } ++ /^X\(\/\/\)[^/].*/{ s//\1/; q; } ++ /^X\(\/\/\)$/{ s//\1/; q; } ++ /^X\(\/\).*/{ s//\1/; q; } ++ s/.*/./; q'` ++ done ++ test ! -n "$as_dirs" || mkdir $as_dirs ++ fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5 ++echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;} ++ { (exit 1); exit 1; }; }; } ++ ++ ac_builddir=. ++ ++if test "$ac_dir" != .; then ++ ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'` ++ # A "../" for each directory in $ac_dir_suffix. ++ ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'` ++else ++ ac_dir_suffix= ac_top_builddir= ++fi ++ ++case $srcdir in ++ .) # No --srcdir option. We are building in place. ++ ac_srcdir=. ++ if test -z "$ac_top_builddir"; then ++ ac_top_srcdir=. ++ else ++ ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'` ++ fi ;; ++ [\\/]* | ?:[\\/]* ) # Absolute path. ++ ac_srcdir=$srcdir$ac_dir_suffix; ++ ac_top_srcdir=$srcdir ;; ++ *) # Relative path. ++ ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix ++ ac_top_srcdir=$ac_top_builddir$srcdir ;; ++esac ++# Don't blindly perform a `cd "$ac_dir"/$ac_foo && pwd` since $ac_foo can be ++# absolute. ++ac_abs_builddir=`cd "$ac_dir" && cd $ac_builddir && pwd` ++ac_abs_top_builddir=`cd "$ac_dir" && cd ${ac_top_builddir}. && pwd` ++ac_abs_srcdir=`cd "$ac_dir" && cd $ac_srcdir && pwd` ++ac_abs_top_srcdir=`cd "$ac_dir" && cd $ac_top_srcdir && pwd` ++ ++ ++ case $INSTALL in ++ [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;; ++ *) ac_INSTALL=$ac_top_builddir$INSTALL ;; ++ esac ++ ++ if test x"$ac_file" != x-; then ++ { echo "$as_me:$LINENO: creating $ac_file" >&5 ++echo "$as_me: creating $ac_file" >&6;} ++ rm -f "$ac_file" ++ fi ++ # Let's still pretend it is `configure' which instantiates (i.e., don't ++ # use $as_me), people would be surprised to read: ++ # /* config.h. Generated by config.status. */ ++ if test x"$ac_file" = x-; then ++ configure_input= ++ else ++ configure_input="$ac_file. " ++ fi ++ configure_input=$configure_input"Generated from `echo $ac_file_in | ++ sed 's,.*/,,'` by configure." ++ ++ # First look for the input files in the build tree, otherwise in the ++ # src tree. ++ ac_file_inputs=`IFS=: ++ for f in $ac_file_in; do ++ case $f in ++ -) echo $tmp/stdin ;; ++ [\\/$]*) ++ # Absolute (can't be DOS-style, as IFS=:) ++ test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5 ++echo "$as_me: error: cannot find input file: $f" >&2;} ++ { (exit 1); exit 1; }; } ++ echo $f;; ++ *) # Relative ++ if test -f "$f"; then ++ # Build tree ++ echo $f ++ elif test -f "$srcdir/$f"; then ++ # Source tree ++ echo $srcdir/$f ++ else ++ # /dev/null tree ++ { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5 ++echo "$as_me: error: cannot find input file: $f" >&2;} ++ { (exit 1); exit 1; }; } ++ fi;; ++ esac ++ done` || { (exit 1); exit 1; } ++_ACEOF ++cat >>$CONFIG_STATUS <<_ACEOF ++ sed "$ac_vpsub ++$extrasub ++_ACEOF ++cat >>$CONFIG_STATUS <<\_ACEOF ++:t ++/@[a-zA-Z_][a-zA-Z_0-9]*@/!b ++s,@configure_input@,$configure_input,;t t ++s,@srcdir@,$ac_srcdir,;t t ++s,@abs_srcdir@,$ac_abs_srcdir,;t t ++s,@top_srcdir@,$ac_top_srcdir,;t t ++s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t ++s,@builddir@,$ac_builddir,;t t ++s,@abs_builddir@,$ac_abs_builddir,;t t ++s,@top_builddir@,$ac_top_builddir,;t t ++s,@abs_top_builddir@,$ac_abs_top_builddir,;t t ++s,@INSTALL@,$ac_INSTALL,;t t ++" $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out ++ rm -f $tmp/stdin ++ if test x"$ac_file" != x-; then ++ mv $tmp/out $ac_file ++ else ++ cat $tmp/out ++ rm -f $tmp/out ++ fi ++ ++done ++_ACEOF ++cat >>$CONFIG_STATUS <<\_ACEOF ++ ++# ++# CONFIG_COMMANDS section. ++# ++for ac_file in : $CONFIG_COMMANDS; do test "x$ac_file" = x: && continue ++ ac_dest=`echo "$ac_file" | sed 's,:.*,,'` ++ ac_source=`echo "$ac_file" | sed 's,[^:]*:,,'` ++ ac_dir=`(dirname "$ac_dest") 2>/dev/null || ++$as_expr X"$ac_dest" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ ++ X"$ac_dest" : 'X\(//\)[^/]' \| \ ++ X"$ac_dest" : 'X\(//\)$' \| \ ++ X"$ac_dest" : 'X\(/\)' \| \ ++ . : '\(.\)' 2>/dev/null || ++echo X"$ac_dest" | ++ sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; } ++ /^X\(\/\/\)[^/].*/{ s//\1/; q; } ++ /^X\(\/\/\)$/{ s//\1/; q; } ++ /^X\(\/\).*/{ s//\1/; q; } ++ s/.*/./; q'` ++ ac_builddir=. ++ ++if test "$ac_dir" != .; then ++ ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'` ++ # A "../" for each directory in $ac_dir_suffix. ++ ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'` ++else ++ ac_dir_suffix= ac_top_builddir= ++fi ++ ++case $srcdir in ++ .) # No --srcdir option. We are building in place. ++ ac_srcdir=. ++ if test -z "$ac_top_builddir"; then ++ ac_top_srcdir=. ++ else ++ ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'` ++ fi ;; ++ [\\/]* | ?:[\\/]* ) # Absolute path. ++ ac_srcdir=$srcdir$ac_dir_suffix; ++ ac_top_srcdir=$srcdir ;; ++ *) # Relative path. ++ ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix ++ ac_top_srcdir=$ac_top_builddir$srcdir ;; ++esac ++# Don't blindly perform a `cd "$ac_dir"/$ac_foo && pwd` since $ac_foo can be ++# absolute. ++ac_abs_builddir=`cd "$ac_dir" && cd $ac_builddir && pwd` ++ac_abs_top_builddir=`cd "$ac_dir" && cd ${ac_top_builddir}. && pwd` ++ac_abs_srcdir=`cd "$ac_dir" && cd $ac_srcdir && pwd` ++ac_abs_top_srcdir=`cd "$ac_dir" && cd $ac_top_srcdir && pwd` ++ ++ ++ { echo "$as_me:$LINENO: executing $ac_dest commands" >&5 ++echo "$as_me: executing $ac_dest commands" >&6;} ++ case $ac_dest in ++ default ) ++echo "$DEFS" > boehm-cflags ++ ++if test -n "$CONFIG_FILES"; then ++ LD="${ORIGINAL_LD_FOR_MULTILIBS}" ++ ac_file=Makefile . ${gc_basedir}/../config-ml.in ++fi ;; ++ esac ++done ++_ACEOF ++ ++cat >>$CONFIG_STATUS <<\_ACEOF ++ ++{ (exit 0); exit 0; } ++_ACEOF ++chmod +x $CONFIG_STATUS ++ac_clean_files=$ac_clean_files_save ++ ++ ++# configure is writing to config.log, and then calls config.status. ++# config.status does its own redirection, appending to config.log. ++# Unfortunately, on DOS this fails, as config.log is still kept open ++# by configure, so config.status won't be able to write to it; its ++# output is simply discarded. So we exec the FD to /dev/null, ++# effectively closing config.log, so it can be properly (re)opened and ++# appended to by config.status. When coming back to configure, we ++# need to make the FD available again. ++if test "$no_create" != yes; then ++ ac_cs_success=: ++ ac_config_status_args= ++ test "$silent" = yes && ++ ac_config_status_args="$ac_config_status_args --quiet" ++ exec 5>/dev/null ++ $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false ++ exec 5>>config.log ++ # Use ||, not &&, to avoid exiting from the if with $? = 1, which ++ # would make configure fail if this is the last instruction. ++ $ac_cs_success || { (exit 1); exit 1; } ++fi ++ +diff -urNb boehm-gc/autom4te.cache/output.1 boehm-gc/autom4te.cache/output.1 +--- boehm-gc/autom4te.cache/output.1 Wed Dec 31 16:00:00 1969 ++++ boehm-gc/autom4te.cache/output.1 Sat May 31 15:09:31 2003 +@@ -0,0 +1,9496 @@ ++@%:@! /bin/sh ++@%:@ Guess values for system-dependent variables and create Makefiles. ++@%:@ Generated by GNU Autoconf 2.54. ++@%:@ ++@%:@ Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002 ++@%:@ Free Software Foundation, Inc. ++@%:@ This configure script is free software; the Free Software Foundation ++@%:@ gives unlimited permission to copy, distribute and modify it. ++## --------------------- ## ++## M4sh Initialization. ## ++## --------------------- ## ++ ++# Be Bourne compatible ++if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then ++ emulate sh ++ NULLCMD=: ++ # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which ++ # is contrary to our usage. Disable this feature. ++ alias -g '${1+"$@"}'='"$@"' ++elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then ++ set -o posix ++fi ++ ++# Support unset when possible. ++if (FOO=FOO; unset FOO) >/dev/null 2>&1; then ++ as_unset=unset ++else ++ as_unset=false ++fi ++ ++ ++# Work around bugs in pre-3.0 UWIN ksh. ++$as_unset ENV MAIL MAILPATH ++PS1='$ ' ++PS2='> ' ++PS4='+ ' ++ ++# NLS nuisances. ++for as_var in LANG LANGUAGE LC_ALL LC_COLLATE LC_CTYPE LC_NUMERIC LC_MESSAGES LC_TIME ++do ++ if (set +x; test -n "`(eval $as_var=C; export $as_var) 2>&1`"); then ++ eval $as_var=C; export $as_var ++ else ++ $as_unset $as_var ++ fi ++done ++ ++# Required to use basename. ++if expr a : '\(a\)' >/dev/null 2>&1; then ++ as_expr=expr ++else ++ as_expr=false ++fi ++ ++if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then ++ as_basename=basename ++else ++ as_basename=false ++fi ++ ++ ++# Name of the executable. ++as_me=`$as_basename "$0" || ++$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ ++ X"$0" : 'X\(//\)$' \| \ ++ X"$0" : 'X\(/\)$' \| \ ++ . : '\(.\)' 2>/dev/null || ++echo X/"$0" | ++ sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; } ++ /^X\/\(\/\/\)$/{ s//\1/; q; } ++ /^X\/\(\/\).*/{ s//\1/; q; } ++ s/.*/./; q'` ++ ++ ++# PATH needs CR, and LINENO needs CR and PATH. ++# Avoid depending upon Character Ranges. ++as_cr_letters='abcdefghijklmnopqrstuvwxyz' ++as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' ++as_cr_Letters=$as_cr_letters$as_cr_LETTERS ++as_cr_digits='0123456789' ++as_cr_alnum=$as_cr_Letters$as_cr_digits ++ ++# The user is always right. ++if test "${PATH_SEPARATOR+set}" != set; then ++ echo "#! /bin/sh" >conftest.sh ++ echo "exit 0" >>conftest.sh ++ chmod +x conftest.sh ++ if (PATH="/nonexistent;."; conftest.sh) >/dev/null 2>&1; then ++ PATH_SEPARATOR=';' ++ else ++ PATH_SEPARATOR=: ++ fi ++ rm -f conftest.sh ++fi ++ ++ ++ as_lineno_1=$LINENO ++ as_lineno_2=$LINENO ++ as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null` ++ test "x$as_lineno_1" != "x$as_lineno_2" && ++ test "x$as_lineno_3" = "x$as_lineno_2" || { ++ # Find who we are. Look in the path if we contain no path at all ++ # relative or not. ++ case $0 in ++ *[\\/]* ) as_myself=$0 ;; ++ *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break ++done ++ ++ ;; ++ esac ++ # We did not find ourselves, most probably we were run as `sh COMMAND' ++ # in which case we are not to be found in the path. ++ if test "x$as_myself" = x; then ++ as_myself=$0 ++ fi ++ if test ! -f "$as_myself"; then ++ { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2 ++ { (exit 1); exit 1; }; } ++ fi ++ case $CONFIG_SHELL in ++ '') ++ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for as_base in sh bash ksh sh5; do ++ case $as_dir in ++ /*) ++ if ("$as_dir/$as_base" -c ' ++ as_lineno_1=$LINENO ++ as_lineno_2=$LINENO ++ as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null` ++ test "x$as_lineno_1" != "x$as_lineno_2" && ++ test "x$as_lineno_3" = "x$as_lineno_2" ') 2>/dev/null; then ++ $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; } ++ $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; } ++ CONFIG_SHELL=$as_dir/$as_base ++ export CONFIG_SHELL ++ exec "$CONFIG_SHELL" "$0" ${1+"$@"} ++ fi;; ++ esac ++ done ++done ++;; ++ esac ++ ++ # Create $as_me.lineno as a copy of $as_myself, but with $LINENO ++ # uniformly replaced by the line number. The first 'sed' inserts a ++ # line-number line before each line; the second 'sed' does the real ++ # work. The second script uses 'N' to pair each line-number line ++ # with the numbered line, and appends trailing '-' during ++ # substitution so that $LINENO is not a special case at line end. ++ # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the ++ # second 'sed' script. Blame Lee E. McMahon for sed's syntax. :-) ++ sed '=' <$as_myself | ++ sed ' ++ N ++ s,$,-, ++ : loop ++ s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3, ++ t loop ++ s,-$,, ++ s,^['$as_cr_digits']*\n,, ++ ' >$as_me.lineno && ++ chmod +x $as_me.lineno || ++ { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2 ++ { (exit 1); exit 1; }; } ++ ++ # Don't try to exec as it changes $[0], causing all sort of problems ++ # (the dirname of $[0] is not the place where we might find the ++ # original and so on. Autoconf is especially sensible to this). ++ . ./$as_me.lineno ++ # Exit status is that of the last command. ++ exit ++} ++ ++ ++case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in ++ *c*,-n*) ECHO_N= ECHO_C=' ++' ECHO_T=' ' ;; ++ *c*,* ) ECHO_N=-n ECHO_C= ECHO_T= ;; ++ *) ECHO_N= ECHO_C='\c' ECHO_T= ;; ++esac ++ ++if expr a : '\(a\)' >/dev/null 2>&1; then ++ as_expr=expr ++else ++ as_expr=false ++fi ++ ++rm -f conf$$ conf$$.exe conf$$.file ++echo >conf$$.file ++if ln -s conf$$.file conf$$ 2>/dev/null; then ++ # We could just check for DJGPP; but this test a) works b) is more generic ++ # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04). ++ if test -f conf$$.exe; then ++ # Don't use ln at all; we don't have any links ++ as_ln_s='cp -p' ++ else ++ as_ln_s='ln -s' ++ fi ++elif ln conf$$.file conf$$ 2>/dev/null; then ++ as_ln_s=ln ++else ++ as_ln_s='cp -p' ++fi ++rm -f conf$$ conf$$.exe conf$$.file ++ ++if mkdir -p . 2>/dev/null; then ++ as_mkdir_p=: ++else ++ as_mkdir_p=false ++fi ++ ++as_executable_p="test -f" ++ ++# Sed expression to map a string onto a valid CPP name. ++as_tr_cpp="sed y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g" ++ ++# Sed expression to map a string onto a valid variable name. ++as_tr_sh="sed y%*+%pp%;s%[^_$as_cr_alnum]%_%g" ++ ++ ++# IFS ++# We need space, tab and new line, in precisely that order. ++as_nl=' ++' ++IFS=" $as_nl" ++ ++# CDPATH. ++$as_unset CDPATH ++ ++ ++# Find the correct PATH separator. Usually this is `:', but ++# DJGPP uses `;' like DOS. ++if test "X${PATH_SEPARATOR+set}" != Xset; then ++ UNAME=${UNAME-`uname 2>/dev/null`} ++ case X$UNAME in ++ *-DOS) lt_cv_sys_path_separator=';' ;; ++ *) lt_cv_sys_path_separator=':' ;; ++ esac ++ PATH_SEPARATOR=$lt_cv_sys_path_separator ++fi ++ ++ ++# Check that we are running under the correct shell. ++SHELL=${CONFIG_SHELL-/bin/sh} ++ ++case X$ECHO in ++X*--fallback-echo) ++ # Remove one level of quotation (which was required for Make). ++ ECHO=`echo "$ECHO" | sed 's,\\\\\$\\$0,'$0','` ++ ;; ++esac ++ ++echo=${ECHO-echo} ++if test "X$1" = X--no-reexec; then ++ # Discard the --no-reexec flag, and continue. ++ shift ++elif test "X$1" = X--fallback-echo; then ++ # Avoid inline document here, it may be left over ++ : ++elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then ++ # Yippee, $echo works! ++ : ++else ++ # Restart under the correct shell. ++ exec $SHELL "$0" --no-reexec ${1+"$@"} ++fi ++ ++if test "X$1" = X--fallback-echo; then ++ # used as fallback echo ++ shift ++ cat </dev/null && ++ echo_test_string="`eval $cmd`" && ++ (test "X$echo_test_string" = "X$echo_test_string") 2>/dev/null ++ then ++ break ++ fi ++ done ++fi ++ ++if test "X`($echo '\t') 2>/dev/null`" = 'X\t' && ++ echo_testing_string=`($echo "$echo_test_string") 2>/dev/null` && ++ test "X$echo_testing_string" = "X$echo_test_string"; then ++ : ++else ++ # The Solaris, AIX, and Digital Unix default echo programs unquote ++ # backslashes. This makes it impossible to quote backslashes using ++ # echo "$something" | sed 's/\\/\\\\/g' ++ # ++ # So, first we look for a working echo in the user's PATH. ++ ++ IFS="${IFS= }"; save_ifs="$IFS"; IFS=$PATH_SEPARATOR ++ for dir in $PATH /usr/ucb; do ++ if (test -f $dir/echo || test -f $dir/echo$ac_exeext) && ++ test "X`($dir/echo '\t') 2>/dev/null`" = 'X\t' && ++ echo_testing_string=`($dir/echo "$echo_test_string") 2>/dev/null` && ++ test "X$echo_testing_string" = "X$echo_test_string"; then ++ echo="$dir/echo" ++ break ++ fi ++ done ++ IFS="$save_ifs" ++ ++ if test "X$echo" = Xecho; then ++ # We didn't find a better echo, so look for alternatives. ++ if test "X`(print -r '\t') 2>/dev/null`" = 'X\t' && ++ echo_testing_string=`(print -r "$echo_test_string") 2>/dev/null` && ++ test "X$echo_testing_string" = "X$echo_test_string"; then ++ # This shell has a builtin print -r that does the trick. ++ echo='print -r' ++ elif (test -f /bin/ksh || test -f /bin/ksh$ac_exeext) && ++ test "X$CONFIG_SHELL" != X/bin/ksh; then ++ # If we have ksh, try running configure again with it. ++ ORIGINAL_CONFIG_SHELL=${CONFIG_SHELL-/bin/sh} ++ export ORIGINAL_CONFIG_SHELL ++ CONFIG_SHELL=/bin/ksh ++ export CONFIG_SHELL ++ exec $CONFIG_SHELL "$0" --no-reexec ${1+"$@"} ++ else ++ # Try using printf. ++ echo='printf %s\n' ++ if test "X`($echo '\t') 2>/dev/null`" = 'X\t' && ++ echo_testing_string=`($echo "$echo_test_string") 2>/dev/null` && ++ test "X$echo_testing_string" = "X$echo_test_string"; then ++ # Cool, printf works ++ : ++ elif echo_testing_string=`($ORIGINAL_CONFIG_SHELL "$0" --fallback-echo '\t') 2>/dev/null` && ++ test "X$echo_testing_string" = 'X\t' && ++ echo_testing_string=`($ORIGINAL_CONFIG_SHELL "$0" --fallback-echo "$echo_test_string") 2>/dev/null` && ++ test "X$echo_testing_string" = "X$echo_test_string"; then ++ CONFIG_SHELL=$ORIGINAL_CONFIG_SHELL ++ export CONFIG_SHELL ++ SHELL="$CONFIG_SHELL" ++ export SHELL ++ echo="$CONFIG_SHELL $0 --fallback-echo" ++ elif echo_testing_string=`($CONFIG_SHELL "$0" --fallback-echo '\t') 2>/dev/null` && ++ test "X$echo_testing_string" = 'X\t' && ++ echo_testing_string=`($CONFIG_SHELL "$0" --fallback-echo "$echo_test_string") 2>/dev/null` && ++ test "X$echo_testing_string" = "X$echo_test_string"; then ++ echo="$CONFIG_SHELL $0 --fallback-echo" ++ else ++ # maybe with a smaller string... ++ prev=: ++ ++ for cmd in 'echo test' 'sed 2q "$0"' 'sed 10q "$0"' 'sed 20q "$0"' 'sed 50q "$0"'; do ++ if (test "X$echo_test_string" = "X`eval $cmd`") 2>/dev/null ++ then ++ break ++ fi ++ prev="$cmd" ++ done ++ ++ if test "$prev" != 'sed 50q "$0"'; then ++ echo_test_string=`eval $prev` ++ export echo_test_string ++ exec ${ORIGINAL_CONFIG_SHELL-${CONFIG_SHELL-/bin/sh}} "$0" ${1+"$@"} ++ else ++ # Oops. We lost completely, so just stick with echo. ++ echo=echo ++ fi ++ fi ++ fi ++ fi ++fi ++fi ++ ++# Copy echo and quote the copy suitably for passing to libtool from ++# the Makefile, instead of quoting the original, which is used later. ++ECHO=$echo ++if test "X$ECHO" = "X$CONFIG_SHELL $0 --fallback-echo"; then ++ ECHO="$CONFIG_SHELL \\\$\$0 --fallback-echo" ++fi ++ ++ ++ ++# Name of the host. ++# hostname on some systems (SVR3.2, Linux) returns a bogus exit status, ++# so uname gets run too. ++ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q` ++ ++exec 6>&1 ++ ++# ++# Initializations. ++# ++ac_default_prefix=/usr/local ++ac_config_libobj_dir=. ++cross_compiling=no ++subdirs= ++MFLAGS= ++MAKEFLAGS= ++SHELL=${CONFIG_SHELL-/bin/sh} ++ ++# Maximum number of lines to put in a shell here document. ++# This variable seems obsolete. It should probably be removed, and ++# only ac_max_sed_lines should be used. ++: ${ac_max_here_lines=38} ++ ++# Identity of this package. ++PACKAGE_NAME= ++PACKAGE_TARNAME= ++PACKAGE_VERSION= ++PACKAGE_STRING= ++PACKAGE_BUGREPORT= ++ ++ac_unique_file="gcj_mlc.c" ++# Factoring default headers for most tests. ++ac_includes_default="\ ++#include ++#if HAVE_SYS_TYPES_H ++# include ++#endif ++#if HAVE_SYS_STAT_H ++# include ++#endif ++#if STDC_HEADERS ++# include ++# include ++#else ++# if HAVE_STDLIB_H ++# include ++# endif ++#endif ++#if HAVE_STRING_H ++# if !STDC_HEADERS && HAVE_MEMORY_H ++# include ++# endif ++# include ++#endif ++#if HAVE_STRINGS_H ++# include ++#endif ++#if HAVE_INTTYPES_H ++# include ++#else ++# if HAVE_STDINT_H ++# include ++# endif ++#endif ++#if HAVE_UNISTD_H ++# include ++#endif" ++ ++ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS gc_basedir build build_cpu build_vendor build_os host host_cpu host_vendor host_os target target_cpu target_vendor target_os mkinstalldirs INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA PACKAGE VERSION ACLOCAL AUTOCONF AUTOMAKE AUTOHEADER MAKEINFO AMTAR install_sh STRIP ac_ct_STRIP INSTALL_STRIP_PROGRAM AWK SET_MAKE AS ac_ct_AS AR ac_ct_AR RANLIB ac_ct_RANLIB MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT GC_CFLAGS CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT DEPDIR am__include am__quote AMDEP_TRUE AMDEP_FALSE AMDEPBACKSLASH CCDEPMODE LN_S ECHO CPP EGREP LIBTOOL THREADLIBS POWERPC_DARWIN_TRUE POWERPC_DARWIN_FALSE EXTRA_TEST_LIBS target_all CXX INCLUDES CXXINCLUDES addobjs MY_CFLAGS USE_LIBDIR_TRUE USE_LIBDIR_FALSE LIB@&t@OBJS LTLIBOBJS' ++ac_subst_files='' ++ ++# Initialize some variables set by options. ++ac_init_help= ++ac_init_version=false ++# The variables have the same names as the options, with ++# dashes changed to underlines. ++cache_file=/dev/null ++exec_prefix=NONE ++no_create= ++no_recursion= ++prefix=NONE ++program_prefix=NONE ++program_suffix=NONE ++program_transform_name=s,x,x, ++silent= ++site= ++srcdir= ++verbose= ++x_includes=NONE ++x_libraries=NONE ++ ++# Installation directory options. ++# These are left unexpanded so users can "make install exec_prefix=/foo" ++# and all the variables that are supposed to be based on exec_prefix ++# by default will actually change. ++# Use braces instead of parens because sh, perl, etc. also accept them. ++bindir='${exec_prefix}/bin' ++sbindir='${exec_prefix}/sbin' ++libexecdir='${exec_prefix}/libexec' ++datadir='${prefix}/share' ++sysconfdir='${prefix}/etc' ++sharedstatedir='${prefix}/com' ++localstatedir='${prefix}/var' ++libdir='${exec_prefix}/lib' ++includedir='${prefix}/include' ++oldincludedir='/usr/include' ++infodir='${prefix}/info' ++mandir='${prefix}/man' ++ ++ac_prev= ++for ac_option ++do ++ # If the previous option needs an argument, assign it. ++ if test -n "$ac_prev"; then ++ eval "$ac_prev=\$ac_option" ++ ac_prev= ++ continue ++ fi ++ ++ ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'` ++ ++ # Accept the important Cygnus configure options, so we can diagnose typos. ++ ++ case $ac_option in ++ ++ -bindir | --bindir | --bindi | --bind | --bin | --bi) ++ ac_prev=bindir ;; ++ -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*) ++ bindir=$ac_optarg ;; ++ ++ -build | --build | --buil | --bui | --bu) ++ ac_prev=build_alias ;; ++ -build=* | --build=* | --buil=* | --bui=* | --bu=*) ++ build_alias=$ac_optarg ;; ++ ++ -cache-file | --cache-file | --cache-fil | --cache-fi \ ++ | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c) ++ ac_prev=cache_file ;; ++ -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ ++ | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*) ++ cache_file=$ac_optarg ;; ++ ++ --config-cache | -C) ++ cache_file=config.cache ;; ++ ++ -datadir | --datadir | --datadi | --datad | --data | --dat | --da) ++ ac_prev=datadir ;; ++ -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \ ++ | --da=*) ++ datadir=$ac_optarg ;; ++ ++ -disable-* | --disable-*) ++ ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'` ++ # Reject names that are not valid shell variable names. ++ expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null && ++ { echo "$as_me: error: invalid feature name: $ac_feature" >&2 ++ { (exit 1); exit 1; }; } ++ ac_feature=`echo $ac_feature | sed 's/-/_/g'` ++ eval "enable_$ac_feature=no" ;; ++ ++ -enable-* | --enable-*) ++ ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'` ++ # Reject names that are not valid shell variable names. ++ expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null && ++ { echo "$as_me: error: invalid feature name: $ac_feature" >&2 ++ { (exit 1); exit 1; }; } ++ ac_feature=`echo $ac_feature | sed 's/-/_/g'` ++ case $ac_option in ++ *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;; ++ *) ac_optarg=yes ;; ++ esac ++ eval "enable_$ac_feature='$ac_optarg'" ;; ++ ++ -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ ++ | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ ++ | --exec | --exe | --ex) ++ ac_prev=exec_prefix ;; ++ -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \ ++ | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \ ++ | --exec=* | --exe=* | --ex=*) ++ exec_prefix=$ac_optarg ;; ++ ++ -gas | --gas | --ga | --g) ++ # Obsolete; use --with-gas. ++ with_gas=yes ;; ++ ++ -help | --help | --hel | --he | -h) ++ ac_init_help=long ;; ++ -help=r* | --help=r* | --hel=r* | --he=r* | -hr*) ++ ac_init_help=recursive ;; ++ -help=s* | --help=s* | --hel=s* | --he=s* | -hs*) ++ ac_init_help=short ;; ++ ++ -host | --host | --hos | --ho) ++ ac_prev=host_alias ;; ++ -host=* | --host=* | --hos=* | --ho=*) ++ host_alias=$ac_optarg ;; ++ ++ -includedir | --includedir | --includedi | --included | --include \ ++ | --includ | --inclu | --incl | --inc) ++ ac_prev=includedir ;; ++ -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \ ++ | --includ=* | --inclu=* | --incl=* | --inc=*) ++ includedir=$ac_optarg ;; ++ ++ -infodir | --infodir | --infodi | --infod | --info | --inf) ++ ac_prev=infodir ;; ++ -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*) ++ infodir=$ac_optarg ;; ++ ++ -libdir | --libdir | --libdi | --libd) ++ ac_prev=libdir ;; ++ -libdir=* | --libdir=* | --libdi=* | --libd=*) ++ libdir=$ac_optarg ;; ++ ++ -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \ ++ | --libexe | --libex | --libe) ++ ac_prev=libexecdir ;; ++ -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \ ++ | --libexe=* | --libex=* | --libe=*) ++ libexecdir=$ac_optarg ;; ++ ++ -localstatedir | --localstatedir | --localstatedi | --localstated \ ++ | --localstate | --localstat | --localsta | --localst \ ++ | --locals | --local | --loca | --loc | --lo) ++ ac_prev=localstatedir ;; ++ -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \ ++ | --localstate=* | --localstat=* | --localsta=* | --localst=* \ ++ | --locals=* | --local=* | --loca=* | --loc=* | --lo=*) ++ localstatedir=$ac_optarg ;; ++ ++ -mandir | --mandir | --mandi | --mand | --man | --ma | --m) ++ ac_prev=mandir ;; ++ -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*) ++ mandir=$ac_optarg ;; ++ ++ -nfp | --nfp | --nf) ++ # Obsolete; use --without-fp. ++ with_fp=no ;; ++ ++ -no-create | --no-create | --no-creat | --no-crea | --no-cre \ ++ | --no-cr | --no-c | -n) ++ no_create=yes ;; ++ ++ -no-recursion | --no-recursion | --no-recursio | --no-recursi \ ++ | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) ++ no_recursion=yes ;; ++ ++ -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \ ++ | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \ ++ | --oldin | --oldi | --old | --ol | --o) ++ ac_prev=oldincludedir ;; ++ -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \ ++ | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \ ++ | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*) ++ oldincludedir=$ac_optarg ;; ++ ++ -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) ++ ac_prev=prefix ;; ++ -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) ++ prefix=$ac_optarg ;; ++ ++ -program-prefix | --program-prefix | --program-prefi | --program-pref \ ++ | --program-pre | --program-pr | --program-p) ++ ac_prev=program_prefix ;; ++ -program-prefix=* | --program-prefix=* | --program-prefi=* \ ++ | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*) ++ program_prefix=$ac_optarg ;; ++ ++ -program-suffix | --program-suffix | --program-suffi | --program-suff \ ++ | --program-suf | --program-su | --program-s) ++ ac_prev=program_suffix ;; ++ -program-suffix=* | --program-suffix=* | --program-suffi=* \ ++ | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*) ++ program_suffix=$ac_optarg ;; ++ ++ -program-transform-name | --program-transform-name \ ++ | --program-transform-nam | --program-transform-na \ ++ | --program-transform-n | --program-transform- \ ++ | --program-transform | --program-transfor \ ++ | --program-transfo | --program-transf \ ++ | --program-trans | --program-tran \ ++ | --progr-tra | --program-tr | --program-t) ++ ac_prev=program_transform_name ;; ++ -program-transform-name=* | --program-transform-name=* \ ++ | --program-transform-nam=* | --program-transform-na=* \ ++ | --program-transform-n=* | --program-transform-=* \ ++ | --program-transform=* | --program-transfor=* \ ++ | --program-transfo=* | --program-transf=* \ ++ | --program-trans=* | --program-tran=* \ ++ | --progr-tra=* | --program-tr=* | --program-t=*) ++ program_transform_name=$ac_optarg ;; ++ ++ -q | -quiet | --quiet | --quie | --qui | --qu | --q \ ++ | -silent | --silent | --silen | --sile | --sil) ++ silent=yes ;; ++ ++ -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb) ++ ac_prev=sbindir ;; ++ -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \ ++ | --sbi=* | --sb=*) ++ sbindir=$ac_optarg ;; ++ ++ -sharedstatedir | --sharedstatedir | --sharedstatedi \ ++ | --sharedstated | --sharedstate | --sharedstat | --sharedsta \ ++ | --sharedst | --shareds | --shared | --share | --shar \ ++ | --sha | --sh) ++ ac_prev=sharedstatedir ;; ++ -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \ ++ | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \ ++ | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \ ++ | --sha=* | --sh=*) ++ sharedstatedir=$ac_optarg ;; ++ ++ -site | --site | --sit) ++ ac_prev=site ;; ++ -site=* | --site=* | --sit=*) ++ site=$ac_optarg ;; ++ ++ -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) ++ ac_prev=srcdir ;; ++ -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) ++ srcdir=$ac_optarg ;; ++ ++ -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \ ++ | --syscon | --sysco | --sysc | --sys | --sy) ++ ac_prev=sysconfdir ;; ++ -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \ ++ | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*) ++ sysconfdir=$ac_optarg ;; ++ ++ -target | --target | --targe | --targ | --tar | --ta | --t) ++ ac_prev=target_alias ;; ++ -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) ++ target_alias=$ac_optarg ;; ++ ++ -v | -verbose | --verbose | --verbos | --verbo | --verb) ++ verbose=yes ;; ++ ++ -version | --version | --versio | --versi | --vers | -V) ++ ac_init_version=: ;; ++ ++ -with-* | --with-*) ++ ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'` ++ # Reject names that are not valid shell variable names. ++ expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null && ++ { echo "$as_me: error: invalid package name: $ac_package" >&2 ++ { (exit 1); exit 1; }; } ++ ac_package=`echo $ac_package| sed 's/-/_/g'` ++ case $ac_option in ++ *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;; ++ *) ac_optarg=yes ;; ++ esac ++ eval "with_$ac_package='$ac_optarg'" ;; ++ ++ -without-* | --without-*) ++ ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'` ++ # Reject names that are not valid shell variable names. ++ expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null && ++ { echo "$as_me: error: invalid package name: $ac_package" >&2 ++ { (exit 1); exit 1; }; } ++ ac_package=`echo $ac_package | sed 's/-/_/g'` ++ eval "with_$ac_package=no" ;; ++ ++ --x) ++ # Obsolete; use --with-x. ++ with_x=yes ;; ++ ++ -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \ ++ | --x-incl | --x-inc | --x-in | --x-i) ++ ac_prev=x_includes ;; ++ -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \ ++ | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*) ++ x_includes=$ac_optarg ;; ++ ++ -x-libraries | --x-libraries | --x-librarie | --x-librari \ ++ | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l) ++ ac_prev=x_libraries ;; ++ -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \ ++ | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) ++ x_libraries=$ac_optarg ;; ++ ++ -*) { echo "$as_me: error: unrecognized option: $ac_option ++Try \`$0 --help' for more information." >&2 ++ { (exit 1); exit 1; }; } ++ ;; ++ ++ *=*) ++ ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='` ++ # Reject names that are not valid shell variable names. ++ expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null && ++ { echo "$as_me: error: invalid variable name: $ac_envvar" >&2 ++ { (exit 1); exit 1; }; } ++ ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ++ eval "$ac_envvar='$ac_optarg'" ++ export $ac_envvar ;; ++ ++ *) ++ # FIXME: should be removed in autoconf 3.0. ++ echo "$as_me: WARNING: you should use --build, --host, --target" >&2 ++ expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null && ++ echo "$as_me: WARNING: invalid host type: $ac_option" >&2 ++ : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option} ++ ;; ++ ++ esac ++done ++ ++if test -n "$ac_prev"; then ++ ac_option=--`echo $ac_prev | sed 's/_/-/g'` ++ { echo "$as_me: error: missing argument to $ac_option" >&2 ++ { (exit 1); exit 1; }; } ++fi ++ ++# Be sure to have absolute paths. ++for ac_var in exec_prefix prefix ++do ++ eval ac_val=$`echo $ac_var` ++ case $ac_val in ++ [\\/$]* | ?:[\\/]* | NONE | '' ) ;; ++ *) { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2 ++ { (exit 1); exit 1; }; };; ++ esac ++done ++ ++# Be sure to have absolute paths. ++for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \ ++ localstatedir libdir includedir oldincludedir infodir mandir ++do ++ eval ac_val=$`echo $ac_var` ++ case $ac_val in ++ [\\/$]* | ?:[\\/]* ) ;; ++ *) { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2 ++ { (exit 1); exit 1; }; };; ++ esac ++done ++ ++# There might be people who depend on the old broken behavior: `$host' ++# used to hold the argument of --host etc. ++# FIXME: To remove some day. ++build=$build_alias ++host=$host_alias ++target=$target_alias ++ ++# FIXME: To remove some day. ++if test "x$host_alias" != x; then ++ if test "x$build_alias" = x; then ++ cross_compiling=maybe ++ echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host. ++ If a cross compiler is detected then cross compile mode will be used." >&2 ++ elif test "x$build_alias" != "x$host_alias"; then ++ cross_compiling=yes ++ fi ++fi ++ ++ac_tool_prefix= ++test -n "$host_alias" && ac_tool_prefix=$host_alias- ++ ++test "$silent" = yes && exec 6>/dev/null ++ ++ ++# Find the source files, if location was not specified. ++if test -z "$srcdir"; then ++ ac_srcdir_defaulted=yes ++ # Try the directory containing this script, then its parent. ++ ac_confdir=`(dirname "$0") 2>/dev/null || ++$as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ ++ X"$0" : 'X\(//\)[^/]' \| \ ++ X"$0" : 'X\(//\)$' \| \ ++ X"$0" : 'X\(/\)' \| \ ++ . : '\(.\)' 2>/dev/null || ++echo X"$0" | ++ sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; } ++ /^X\(\/\/\)[^/].*/{ s//\1/; q; } ++ /^X\(\/\/\)$/{ s//\1/; q; } ++ /^X\(\/\).*/{ s//\1/; q; } ++ s/.*/./; q'` ++ srcdir=$ac_confdir ++ if test ! -r $srcdir/$ac_unique_file; then ++ srcdir=.. ++ fi ++else ++ ac_srcdir_defaulted=no ++fi ++if test ! -r $srcdir/$ac_unique_file; then ++ if test "$ac_srcdir_defaulted" = yes; then ++ { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2 ++ { (exit 1); exit 1; }; } ++ else ++ { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2 ++ { (exit 1); exit 1; }; } ++ fi ++fi ++(cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null || ++ { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2 ++ { (exit 1); exit 1; }; } ++srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'` ++ac_env_build_alias_set=${build_alias+set} ++ac_env_build_alias_value=$build_alias ++ac_cv_env_build_alias_set=${build_alias+set} ++ac_cv_env_build_alias_value=$build_alias ++ac_env_host_alias_set=${host_alias+set} ++ac_env_host_alias_value=$host_alias ++ac_cv_env_host_alias_set=${host_alias+set} ++ac_cv_env_host_alias_value=$host_alias ++ac_env_target_alias_set=${target_alias+set} ++ac_env_target_alias_value=$target_alias ++ac_cv_env_target_alias_set=${target_alias+set} ++ac_cv_env_target_alias_value=$target_alias ++ac_env_CC_set=${CC+set} ++ac_env_CC_value=$CC ++ac_cv_env_CC_set=${CC+set} ++ac_cv_env_CC_value=$CC ++ac_env_CFLAGS_set=${CFLAGS+set} ++ac_env_CFLAGS_value=$CFLAGS ++ac_cv_env_CFLAGS_set=${CFLAGS+set} ++ac_cv_env_CFLAGS_value=$CFLAGS ++ac_env_LDFLAGS_set=${LDFLAGS+set} ++ac_env_LDFLAGS_value=$LDFLAGS ++ac_cv_env_LDFLAGS_set=${LDFLAGS+set} ++ac_cv_env_LDFLAGS_value=$LDFLAGS ++ac_env_CPPFLAGS_set=${CPPFLAGS+set} ++ac_env_CPPFLAGS_value=$CPPFLAGS ++ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set} ++ac_cv_env_CPPFLAGS_value=$CPPFLAGS ++ac_env_CPP_set=${CPP+set} ++ac_env_CPP_value=$CPP ++ac_cv_env_CPP_set=${CPP+set} ++ac_cv_env_CPP_value=$CPP ++ ++# ++# Report the --help message. ++# ++if test "$ac_init_help" = "long"; then ++ # Omit some internal or obsolete options to make the list less imposing. ++ # This message is too long to be a string in the A/UX 3.1 sh. ++ cat <<_ACEOF ++\`configure' configures this package to adapt to many kinds of systems. ++ ++Usage: $0 [OPTION]... [VAR=VALUE]... ++ ++To assign environment variables (e.g., CC, CFLAGS...), specify them as ++VAR=VALUE. See below for descriptions of some of the useful variables. ++ ++Defaults for the options are specified in brackets. ++ ++Configuration: ++ -h, --help display this help and exit ++ --help=short display options specific to this package ++ --help=recursive display the short help of all the included packages ++ -V, --version display version information and exit ++ -q, --quiet, --silent do not print \`checking...' messages ++ --cache-file=FILE cache test results in FILE [disabled] ++ -C, --config-cache alias for \`--cache-file=config.cache' ++ -n, --no-create do not create output files ++ --srcdir=DIR find the sources in DIR [configure dir or \`..'] ++ ++_ACEOF ++ ++ cat <<_ACEOF ++Installation directories: ++ --prefix=PREFIX install architecture-independent files in PREFIX ++ [$ac_default_prefix] ++ --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX ++ [PREFIX] ++ ++By default, \`make install' will install all the files in ++\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify ++an installation prefix other than \`$ac_default_prefix' using \`--prefix', ++for instance \`--prefix=\$HOME'. ++ ++For better control, use the options below. ++ ++Fine tuning of the installation directories: ++ --bindir=DIR user executables [EPREFIX/bin] ++ --sbindir=DIR system admin executables [EPREFIX/sbin] ++ --libexecdir=DIR program executables [EPREFIX/libexec] ++ --datadir=DIR read-only architecture-independent data [PREFIX/share] ++ --sysconfdir=DIR read-only single-machine data [PREFIX/etc] ++ --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com] ++ --localstatedir=DIR modifiable single-machine data [PREFIX/var] ++ --libdir=DIR object code libraries [EPREFIX/lib] ++ --includedir=DIR C header files [PREFIX/include] ++ --oldincludedir=DIR C header files for non-gcc [/usr/include] ++ --infodir=DIR info documentation [PREFIX/info] ++ --mandir=DIR man documentation [PREFIX/man] ++_ACEOF ++ ++ cat <<\_ACEOF ++ ++Program names: ++ --program-prefix=PREFIX prepend PREFIX to installed program names ++ --program-suffix=SUFFIX append SUFFIX to installed program names ++ --program-transform-name=PROGRAM run sed PROGRAM on installed program names ++ ++System types: ++ --build=BUILD configure for building on BUILD [guessed] ++ --host=HOST cross-compile to build programs to run on HOST [BUILD] ++ --target=TARGET configure for building compilers for TARGET [HOST] ++_ACEOF ++fi ++ ++if test -n "$ac_init_help"; then ++ ++ cat <<\_ACEOF ++ ++Optional Features: ++ --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no) ++ --enable-FEATURE[=ARG] include FEATURE [ARG=yes] ++ --enable-multilib build many library versions (default) ++ --enable-maintainer-mode enable make rules and dependencies not useful ++ (and sometimes confusing) to the casual installer ++ --enable-shared=PKGS build shared libraries default=yes ++ --enable-static=PKGS build static libraries default=yes ++ --enable-fast-install=PKGS optimize for fast installation default=yes ++ --disable-dependency-tracking Speeds up one-time builds ++ --enable-dependency-tracking Do not reject slow dependency extractors ++ --disable-libtool-lock avoid locking (might break parallel builds) ++ --enable-parallel-mark parallelize marking and free list construction ++ --enable-shared=PKGS build shared libraries default=no ++ --enable-full-debug include full support for pointer backtracing etc. ++ ++Optional Packages: ++ --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] ++ --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) ++ --with-gnu-ld assume the C compiler uses GNU ld default=no ++ --with-pic try to use only PIC/non-PIC objects default=use both ++ --with-target-subdir=SUBDIR ++ configuring with a cross compiler ++ --with-cross-host=HOST configuring with a cross compiler ++ --with-ecos enable runtime eCos target support ++ ++Some influential environment variables: ++ CC C compiler command ++ CFLAGS C compiler flags ++ LDFLAGS linker flags, e.g. -L if you have libraries in a ++ nonstandard directory ++ CPPFLAGS C/C++ preprocessor flags, e.g. -I if you have ++ headers in a nonstandard directory ++ CPP C preprocessor ++ ++Use these variables to override the choices made by `configure' or to help ++it to find libraries and programs with nonstandard names/locations. ++ ++_ACEOF ++fi ++ ++if test "$ac_init_help" = "recursive"; then ++ # If there are subdirs, report their specific --help. ++ ac_popdir=`pwd` ++ for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue ++ test -d $ac_dir || continue ++ ac_builddir=. ++ ++if test "$ac_dir" != .; then ++ ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'` ++ # A "../" for each directory in $ac_dir_suffix. ++ ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'` ++else ++ ac_dir_suffix= ac_top_builddir= ++fi ++ ++case $srcdir in ++ .) # No --srcdir option. We are building in place. ++ ac_srcdir=. ++ if test -z "$ac_top_builddir"; then ++ ac_top_srcdir=. ++ else ++ ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'` ++ fi ;; ++ [\\/]* | ?:[\\/]* ) # Absolute path. ++ ac_srcdir=$srcdir$ac_dir_suffix; ++ ac_top_srcdir=$srcdir ;; ++ *) # Relative path. ++ ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix ++ ac_top_srcdir=$ac_top_builddir$srcdir ;; ++esac ++# Don't blindly perform a `cd "$ac_dir"/$ac_foo && pwd` since $ac_foo can be ++# absolute. ++ac_abs_builddir=`cd "$ac_dir" && cd $ac_builddir && pwd` ++ac_abs_top_builddir=`cd "$ac_dir" && cd ${ac_top_builddir}. && pwd` ++ac_abs_srcdir=`cd "$ac_dir" && cd $ac_srcdir && pwd` ++ac_abs_top_srcdir=`cd "$ac_dir" && cd $ac_top_srcdir && pwd` ++ ++ cd $ac_dir ++ # Check for guested configure; otherwise get Cygnus style configure. ++ if test -f $ac_srcdir/configure.gnu; then ++ echo ++ $SHELL $ac_srcdir/configure.gnu --help=recursive ++ elif test -f $ac_srcdir/configure; then ++ echo ++ $SHELL $ac_srcdir/configure --help=recursive ++ elif test -f $ac_srcdir/configure.ac || ++ test -f $ac_srcdir/configure.in; then ++ echo ++ $ac_configure --help ++ else ++ echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2 ++ fi ++ cd $ac_popdir ++ done ++fi ++ ++test -n "$ac_init_help" && exit 0 ++if $ac_init_version; then ++ cat <<\_ACEOF ++ ++Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002 ++Free Software Foundation, Inc. ++This configure script is free software; the Free Software Foundation ++gives unlimited permission to copy, distribute and modify it. ++_ACEOF ++ exit 0 ++fi ++exec 5>config.log ++cat >&5 <<_ACEOF ++This file contains any messages produced by compilers while ++running configure, to aid debugging if configure makes a mistake. ++ ++It was created by $as_me, which was ++generated by GNU Autoconf 2.54. Invocation command line was ++ ++ $ $0 $@ ++ ++_ACEOF ++{ ++cat <<_ASUNAME ++@%:@@%:@ --------- @%:@@%:@ ++@%:@@%:@ Platform. @%:@@%:@ ++@%:@@%:@ --------- @%:@@%:@ ++ ++hostname = `(hostname || uname -n) 2>/dev/null | sed 1q` ++uname -m = `(uname -m) 2>/dev/null || echo unknown` ++uname -r = `(uname -r) 2>/dev/null || echo unknown` ++uname -s = `(uname -s) 2>/dev/null || echo unknown` ++uname -v = `(uname -v) 2>/dev/null || echo unknown` ++ ++/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown` ++/bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown` ++ ++/bin/arch = `(/bin/arch) 2>/dev/null || echo unknown` ++/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown` ++/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown` ++hostinfo = `(hostinfo) 2>/dev/null || echo unknown` ++/bin/machine = `(/bin/machine) 2>/dev/null || echo unknown` ++/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown` ++/bin/universe = `(/bin/universe) 2>/dev/null || echo unknown` ++ ++_ASUNAME ++ ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ echo "PATH: $as_dir" ++done ++ ++} >&5 ++ ++cat >&5 <<_ACEOF ++ ++ ++@%:@@%:@ ----------- @%:@@%:@ ++@%:@@%:@ Core tests. @%:@@%:@ ++@%:@@%:@ ----------- @%:@@%:@ ++ ++_ACEOF ++ ++ ++# Keep a trace of the command line. ++# Strip out --no-create and --no-recursion so they do not pile up. ++# Also quote any args containing shell meta-characters. ++ac_configure_args= ++ac_sep= ++for ac_arg ++do ++ case $ac_arg in ++ -no-create | --no-create | --no-creat | --no-crea | --no-cre \ ++ | --no-cr | --no-c | -n ) continue ;; ++ -no-recursion | --no-recursion | --no-recursio | --no-recursi \ ++ | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) ++ continue ;; ++ *" "*|*" "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*) ++ ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; ++ esac ++ ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'" ++ # Get rid of the leading space. ++ ac_sep=" " ++done ++ ++# When interrupted or exit'd, cleanup temporary files, and complete ++# config.log. We remove comments because anyway the quotes in there ++# would cause problems or look ugly. ++# WARNING: Be sure not to use single quotes in there, as some shells, ++# such as our DU 5.0 friend, will then `close' the trap. ++trap 'exit_status=$? ++ # Save into config.log some information that might help in debugging. ++ { ++ echo ++ ++ cat <<\_ASBOX ++@%:@@%:@ ---------------- @%:@@%:@ ++@%:@@%:@ Cache variables. @%:@@%:@ ++@%:@@%:@ ---------------- @%:@@%:@ ++_ASBOX ++ echo ++ # The following way of writing the cache mishandles newlines in values, ++{ ++ (set) 2>&1 | ++ case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in ++ *ac_space=\ *) ++ sed -n \ ++ "s/'"'"'/'"'"'\\\\'"'"''"'"'/g; ++ s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p" ++ ;; ++ *) ++ sed -n \ ++ "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p" ++ ;; ++ esac; ++} ++ echo ++ ++ cat <<\_ASBOX ++@%:@@%:@ ----------------- @%:@@%:@ ++@%:@@%:@ Output variables. @%:@@%:@ ++@%:@@%:@ ----------------- @%:@@%:@ ++_ASBOX ++ echo ++ for ac_var in $ac_subst_vars ++ do ++ eval ac_val=$`echo $ac_var` ++ echo "$ac_var='"'"'$ac_val'"'"'" ++ done | sort ++ echo ++ ++ if test -n "$ac_subst_files"; then ++ cat <<\_ASBOX ++@%:@@%:@ ------------- @%:@@%:@ ++@%:@@%:@ Output files. @%:@@%:@ ++@%:@@%:@ ------------- @%:@@%:@ ++_ASBOX ++ echo ++ for ac_var in $ac_subst_files ++ do ++ eval ac_val=$`echo $ac_var` ++ echo "$ac_var='"'"'$ac_val'"'"'" ++ done | sort ++ echo ++ fi ++ ++ if test -s confdefs.h; then ++ cat <<\_ASBOX ++@%:@@%:@ ----------- @%:@@%:@ ++@%:@@%:@ confdefs.h. @%:@@%:@ ++@%:@@%:@ ----------- @%:@@%:@ ++_ASBOX ++ echo ++ sed "/^$/d" confdefs.h | sort ++ echo ++ fi ++ test "$ac_signal" != 0 && ++ echo "$as_me: caught signal $ac_signal" ++ echo "$as_me: exit $exit_status" ++ } >&5 ++ rm -f core core.* *.core && ++ rm -rf conftest* confdefs* conf$$* $ac_clean_files && ++ exit $exit_status ++ ' 0 ++for ac_signal in 1 2 13 15; do ++ trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal ++done ++ac_signal=0 ++ ++# confdefs.h avoids OS command line length limits that DEFS can exceed. ++rm -rf conftest* confdefs.h ++# AIX cpp loses on an empty file, so make sure it contains at least a newline. ++echo >confdefs.h ++ ++# Predefined preprocessor variables. ++ ++cat >>confdefs.h <<_ACEOF ++@%:@define PACKAGE_NAME "$PACKAGE_NAME" ++_ACEOF ++ ++ ++cat >>confdefs.h <<_ACEOF ++@%:@define PACKAGE_TARNAME "$PACKAGE_TARNAME" ++_ACEOF ++ ++ ++cat >>confdefs.h <<_ACEOF ++@%:@define PACKAGE_VERSION "$PACKAGE_VERSION" ++_ACEOF ++ ++ ++cat >>confdefs.h <<_ACEOF ++@%:@define PACKAGE_STRING "$PACKAGE_STRING" ++_ACEOF ++ ++ ++cat >>confdefs.h <<_ACEOF ++@%:@define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT" ++_ACEOF ++ ++ ++# Let the site file select an alternate cache file if it wants to. ++# Prefer explicitly selected file to automatically selected ones. ++if test -z "$CONFIG_SITE"; then ++ if test "x$prefix" != xNONE; then ++ CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site" ++ else ++ CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site" ++ fi ++fi ++for ac_site_file in $CONFIG_SITE; do ++ if test -r "$ac_site_file"; then ++ { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5 ++echo "$as_me: loading site script $ac_site_file" >&6;} ++ sed 's/^/| /' "$ac_site_file" >&5 ++ . "$ac_site_file" ++ fi ++done ++ ++if test -r "$cache_file"; then ++ # Some versions of bash will fail to source /dev/null (special ++ # files actually), so we avoid doing that. ++ if test -f "$cache_file"; then ++ { echo "$as_me:$LINENO: loading cache $cache_file" >&5 ++echo "$as_me: loading cache $cache_file" >&6;} ++ case $cache_file in ++ [\\/]* | ?:[\\/]* ) . $cache_file;; ++ *) . ./$cache_file;; ++ esac ++ fi ++else ++ { echo "$as_me:$LINENO: creating cache $cache_file" >&5 ++echo "$as_me: creating cache $cache_file" >&6;} ++ >$cache_file ++fi ++ ++# Check that the precious variables saved in the cache have kept the same ++# value. ++ac_cache_corrupted=false ++for ac_var in `(set) 2>&1 | ++ sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do ++ eval ac_old_set=\$ac_cv_env_${ac_var}_set ++ eval ac_new_set=\$ac_env_${ac_var}_set ++ eval ac_old_val="\$ac_cv_env_${ac_var}_value" ++ eval ac_new_val="\$ac_env_${ac_var}_value" ++ case $ac_old_set,$ac_new_set in ++ set,) ++ { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5 ++echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;} ++ ac_cache_corrupted=: ;; ++ ,set) ++ { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5 ++echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;} ++ ac_cache_corrupted=: ;; ++ ,);; ++ *) ++ if test "x$ac_old_val" != "x$ac_new_val"; then ++ { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5 ++echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;} ++ { echo "$as_me:$LINENO: former value: $ac_old_val" >&5 ++echo "$as_me: former value: $ac_old_val" >&2;} ++ { echo "$as_me:$LINENO: current value: $ac_new_val" >&5 ++echo "$as_me: current value: $ac_new_val" >&2;} ++ ac_cache_corrupted=: ++ fi;; ++ esac ++ # Pass precious variables to config.status. ++ if test "$ac_new_set" = set; then ++ case $ac_new_val in ++ *" "*|*" "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*) ++ ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; ++ *) ac_arg=$ac_var=$ac_new_val ;; ++ esac ++ case " $ac_configure_args " in ++ *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy. ++ *) ac_configure_args="$ac_configure_args '$ac_arg'" ;; ++ esac ++ fi ++done ++if $ac_cache_corrupted; then ++ { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5 ++echo "$as_me: error: changes in the environment can compromise the build" >&2;} ++ { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5 ++echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;} ++ { (exit 1); exit 1; }; } ++fi ++ ++ac_ext=c ++ac_cpp='$CPP $CPPFLAGS' ++ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ++ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ++ac_compiler_gnu=$ac_cv_c_compiler_gnu ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++# This works around the fact that libtool configuration may change LD ++# for this particular configuration, but some shells, instead of ++# keeping the changes in LD private, export them just because LD is ++# exported. ++ORIGINAL_LD_FOR_MULTILIBS=$LD ++ ++ac_aux_dir= ++for ac_dir in . $srcdir/.; do ++ if test -f $ac_dir/install-sh; then ++ ac_aux_dir=$ac_dir ++ ac_install_sh="$ac_aux_dir/install-sh -c" ++ break ++ elif test -f $ac_dir/install.sh; then ++ ac_aux_dir=$ac_dir ++ ac_install_sh="$ac_aux_dir/install.sh -c" ++ break ++ elif test -f $ac_dir/shtool; then ++ ac_aux_dir=$ac_dir ++ ac_install_sh="$ac_aux_dir/shtool install -c" ++ break ++ fi ++done ++if test -z "$ac_aux_dir"; then ++ { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in . $srcdir/." >&5 ++echo "$as_me: error: cannot find install-sh or install.sh in . $srcdir/." >&2;} ++ { (exit 1); exit 1; }; } ++fi ++ac_config_guess="$SHELL $ac_aux_dir/config.guess" ++ac_config_sub="$SHELL $ac_aux_dir/config.sub" ++ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure. ++ ++ ++# Make sure we can run config.sub. ++$ac_config_sub sun4 >/dev/null 2>&1 || ++ { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5 ++echo "$as_me: error: cannot run $ac_config_sub" >&2;} ++ { (exit 1); exit 1; }; } ++ ++echo "$as_me:$LINENO: checking build system type" >&5 ++echo $ECHO_N "checking build system type... $ECHO_C" >&6 ++if test "${ac_cv_build+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ ac_cv_build_alias=$build_alias ++test -z "$ac_cv_build_alias" && ++ ac_cv_build_alias=`$ac_config_guess` ++test -z "$ac_cv_build_alias" && ++ { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5 ++echo "$as_me: error: cannot guess build type; you must specify one" >&2;} ++ { (exit 1); exit 1; }; } ++ac_cv_build=`$ac_config_sub $ac_cv_build_alias` || ++ { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5 ++echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;} ++ { (exit 1); exit 1; }; } ++ ++fi ++echo "$as_me:$LINENO: result: $ac_cv_build" >&5 ++echo "${ECHO_T}$ac_cv_build" >&6 ++build=$ac_cv_build ++build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'` ++build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'` ++build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'` ++ ++ ++echo "$as_me:$LINENO: checking host system type" >&5 ++echo $ECHO_N "checking host system type... $ECHO_C" >&6 ++if test "${ac_cv_host+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ ac_cv_host_alias=$host_alias ++test -z "$ac_cv_host_alias" && ++ ac_cv_host_alias=$ac_cv_build_alias ++ac_cv_host=`$ac_config_sub $ac_cv_host_alias` || ++ { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5 ++echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;} ++ { (exit 1); exit 1; }; } ++ ++fi ++echo "$as_me:$LINENO: result: $ac_cv_host" >&5 ++echo "${ECHO_T}$ac_cv_host" >&6 ++host=$ac_cv_host ++host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'` ++host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'` ++host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'` ++ ++ ++am__api_version="1.6" ++# Find a good install program. We prefer a C program (faster), ++# so one script is as good as another. But avoid the broken or ++# incompatible versions: ++# SysV /etc/install, /usr/sbin/install ++# SunOS /usr/etc/install ++# IRIX /sbin/install ++# AIX /bin/install ++# AmigaOS /C/install, which installs bootblocks on floppy discs ++# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag ++# AFS /usr/afsws/bin/install, which mishandles nonexistent args ++# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff" ++# ./install, which can be erroneously created by make from ./install.sh. ++echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5 ++echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6 ++if test -z "$INSTALL"; then ++if test "${ac_cv_path_install+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ # Account for people who put trailing slashes in PATH elements. ++case $as_dir/ in ++ ./ | .// | /cC/* | \ ++ /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \ ++ /usr/ucb/* ) ;; ++ *) ++ # OSF1 and SCO ODT 3.0 have their own names for install. ++ # Don't use installbsd from OSF since it installs stuff as root ++ # by default. ++ for ac_prog in ginstall scoinst install; do ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then ++ if test $ac_prog = install && ++ grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then ++ # AIX install. It has an incompatible calling convention. ++ : ++ elif test $ac_prog = install && ++ grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then ++ # program-specific install script used by HP pwplus--don't use. ++ : ++ else ++ ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c" ++ break 3 ++ fi ++ fi ++ done ++ done ++ ;; ++esac ++done ++ ++ ++fi ++ if test "${ac_cv_path_install+set}" = set; then ++ INSTALL=$ac_cv_path_install ++ else ++ # As a last resort, use the slow shell script. We don't cache a ++ # path for INSTALL within a source directory, because that will ++ # break other packages using the cache if that directory is ++ # removed, or if the path is relative. ++ INSTALL=$ac_install_sh ++ fi ++fi ++echo "$as_me:$LINENO: result: $INSTALL" >&5 ++echo "${ECHO_T}$INSTALL" >&6 ++ ++# Use test -z because SunOS4 sh mishandles braces in ${var-val}. ++# It thinks the first close brace ends the variable substitution. ++test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}' ++ ++test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}' ++ ++test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644' ++ ++echo "$as_me:$LINENO: checking whether build environment is sane" >&5 ++echo $ECHO_N "checking whether build environment is sane... $ECHO_C" >&6 ++# Just in case ++sleep 1 ++echo timestamp > conftest.file ++# Do `set' in a subshell so we don't clobber the current shell's ++# arguments. Must try -L first in case configure is actually a ++# symlink; some systems play weird games with the mod time of symlinks ++# (eg FreeBSD returns the mod time of the symlink's containing ++# directory). ++if ( ++ set X `ls -Lt $srcdir/configure conftest.file 2> /dev/null` ++ if test "$*" = "X"; then ++ # -L didn't work. ++ set X `ls -t $srcdir/configure conftest.file` ++ fi ++ rm -f conftest.file ++ if test "$*" != "X $srcdir/configure conftest.file" \ ++ && test "$*" != "X conftest.file $srcdir/configure"; then ++ ++ # If neither matched, then we have a broken ls. This can happen ++ # if, for instance, CONFIG_SHELL is bash and it inherits a ++ # broken ls alias from the environment. This has actually ++ # happened. Such a system could not be considered "sane". ++ { { echo "$as_me:$LINENO: error: ls -t appears to fail. Make sure there is not a broken ++alias in your environment" >&5 ++echo "$as_me: error: ls -t appears to fail. Make sure there is not a broken ++alias in your environment" >&2;} ++ { (exit 1); exit 1; }; } ++ fi ++ ++ test "$2" = conftest.file ++ ) ++then ++ # Ok. ++ : ++else ++ { { echo "$as_me:$LINENO: error: newly created file is older than distributed files! ++Check your system clock" >&5 ++echo "$as_me: error: newly created file is older than distributed files! ++Check your system clock" >&2;} ++ { (exit 1); exit 1; }; } ++fi ++echo "$as_me:$LINENO: result: yes" >&5 ++echo "${ECHO_T}yes" >&6 ++test "$program_prefix" != NONE && ++ program_transform_name="s,^,$program_prefix,;$program_transform_name" ++# Use a double $ so make ignores it. ++test "$program_suffix" != NONE && ++ program_transform_name="s,\$,$program_suffix,;$program_transform_name" ++# Double any \ or $. echo might interpret backslashes. ++# By default was `s,x,x', remove it if useless. ++cat <<\_ACEOF >conftest.sed ++s/[\\$]/&&/g;s/;s,x,x,$// ++_ACEOF ++program_transform_name=`echo $program_transform_name | sed -f conftest.sed` ++rm conftest.sed ++ ++ ++# expand $ac_aux_dir to an absolute path ++am_aux_dir=`cd $ac_aux_dir && pwd` ++ ++test x"${MISSING+set}" = xset || MISSING="\${SHELL} $am_aux_dir/missing" ++# Use eval to expand $SHELL ++if eval "$MISSING --run true"; then ++ am_missing_run="$MISSING --run " ++else ++ am_missing_run= ++ { echo "$as_me:$LINENO: WARNING: \`missing' script is too old or missing" >&5 ++echo "$as_me: WARNING: \`missing' script is too old or missing" >&2;} ++fi ++ ++for ac_prog in gawk mawk nawk awk ++do ++ # Extract the first word of "$ac_prog", so it can be a program name with args. ++set dummy $ac_prog; ac_word=$2 ++echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 ++if test "${ac_cv_prog_AWK+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$AWK"; then ++ ac_cv_prog_AWK="$AWK" # Let the user override the test. ++else ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ++ ac_cv_prog_AWK="$ac_prog" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++ ++fi ++fi ++AWK=$ac_cv_prog_AWK ++if test -n "$AWK"; then ++ echo "$as_me:$LINENO: result: $AWK" >&5 ++echo "${ECHO_T}$AWK" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++ test -n "$AWK" && break ++done ++ ++echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \${MAKE}" >&5 ++echo $ECHO_N "checking whether ${MAKE-make} sets \${MAKE}... $ECHO_C" >&6 ++set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,./+-,__p_,'` ++if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ cat >conftest.make <<\_ACEOF ++all: ++ @echo 'ac_maketemp="${MAKE}"' ++_ACEOF ++# GNU make sometimes prints "make[1]: Entering...", which would confuse us. ++eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=` ++if test -n "$ac_maketemp"; then ++ eval ac_cv_prog_make_${ac_make}_set=yes ++else ++ eval ac_cv_prog_make_${ac_make}_set=no ++fi ++rm -f conftest.make ++fi ++if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then ++ echo "$as_me:$LINENO: result: yes" >&5 ++echo "${ECHO_T}yes" >&6 ++ SET_MAKE= ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++ SET_MAKE="MAKE=${MAKE-make}" ++fi ++ ++ ++# Check whether --enable-multilib or --disable-multilib was given. ++if test "${enable_multilib+set}" = set; then ++ enableval="$enable_multilib" ++ case "${enableval}" in ++ yes) multilib=yes ;; ++ no) multilib=no ;; ++ *) { { echo "$as_me:$LINENO: error: bad value ${enableval} for multilib option" >&5 ++echo "$as_me: error: bad value ${enableval} for multilib option" >&2;} ++ { (exit 1); exit 1; }; } ;; ++ esac ++else ++ multilib=yes ++fi; ++ ++if test "${srcdir}" = "."; then ++ if test "${with_target_subdir}" != "." -a -n "${with_target_subdir}"; then ++ gc_basedir="${srcdir}/${with_multisrctop}../." ++ else ++ gc_basedir="${srcdir}/${with_multisrctop}." ++ fi ++else ++ gc_basedir="${srcdir}/." ++fi ++ ++ac_aux_dir= ++for ac_dir in $gc_basedir/.. $srcdir/$gc_basedir/..; do ++ if test -f $ac_dir/install-sh; then ++ ac_aux_dir=$ac_dir ++ ac_install_sh="$ac_aux_dir/install-sh -c" ++ break ++ elif test -f $ac_dir/install.sh; then ++ ac_aux_dir=$ac_dir ++ ac_install_sh="$ac_aux_dir/install.sh -c" ++ break ++ elif test -f $ac_dir/shtool; then ++ ac_aux_dir=$ac_dir ++ ac_install_sh="$ac_aux_dir/shtool install -c" ++ break ++ fi ++done ++if test -z "$ac_aux_dir"; then ++ { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $gc_basedir/.. $srcdir/$gc_basedir/.." >&5 ++echo "$as_me: error: cannot find install-sh or install.sh in $gc_basedir/.. $srcdir/$gc_basedir/.." >&2;} ++ { (exit 1); exit 1; }; } ++fi ++ac_config_guess="$SHELL $ac_aux_dir/config.guess" ++ac_config_sub="$SHELL $ac_aux_dir/config.sub" ++ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure. ++ ++if :; then :; else ++ # This overrides the previous occurrence for automake, but not for ++ # autoconf, which is exactly what we want. ++ ac_aux_dir= ++for ac_dir in .. $srcdir/..; do ++ if test -f $ac_dir/install-sh; then ++ ac_aux_dir=$ac_dir ++ ac_install_sh="$ac_aux_dir/install-sh -c" ++ break ++ elif test -f $ac_dir/install.sh; then ++ ac_aux_dir=$ac_dir ++ ac_install_sh="$ac_aux_dir/install.sh -c" ++ break ++ elif test -f $ac_dir/shtool; then ++ ac_aux_dir=$ac_dir ++ ac_install_sh="$ac_aux_dir/shtool install -c" ++ break ++ fi ++done ++if test -z "$ac_aux_dir"; then ++ { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in .. $srcdir/.." >&5 ++echo "$as_me: error: cannot find install-sh or install.sh in .. $srcdir/.." >&2;} ++ { (exit 1); exit 1; }; } ++fi ++ac_config_guess="$SHELL $ac_aux_dir/config.guess" ++ac_config_sub="$SHELL $ac_aux_dir/config.sub" ++ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure. ++ ++fi ++ ++echo "$as_me:$LINENO: checking target system type" >&5 ++echo $ECHO_N "checking target system type... $ECHO_C" >&6 ++if test "${ac_cv_target+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ ac_cv_target_alias=$target_alias ++test "x$ac_cv_target_alias" = "x" && ++ ac_cv_target_alias=$ac_cv_host_alias ++ac_cv_target=`$ac_config_sub $ac_cv_target_alias` || ++ { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5 ++echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;} ++ { (exit 1); exit 1; }; } ++ ++fi ++echo "$as_me:$LINENO: result: $ac_cv_target" >&5 ++echo "${ECHO_T}$ac_cv_target" >&6 ++target=$ac_cv_target ++target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'` ++target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'` ++target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'` ++ ++ ++# The aliases save the names the user supplied, while $host etc. ++# will get canonicalized. ++test -n "$target_alias" && ++ test "$program_prefix$program_suffix$program_transform_name" = \ ++ NONENONEs,x,x, && ++ program_prefix=${target_alias}- ++ ++# This works around an automake problem. ++mkinstalldirs="`cd $ac_aux_dir && ${PWDCMD-pwd}`/mkinstalldirs" ++ ++ ++ # test to see if srcdir already configured ++if test "`cd $srcdir && pwd`" != "`pwd`" && ++ test -f $srcdir/config.status; then ++ { { echo "$as_me:$LINENO: error: source directory already configured; run \"make distclean\" there first" >&5 ++echo "$as_me: error: source directory already configured; run \"make distclean\" there first" >&2;} ++ { (exit 1); exit 1; }; } ++fi ++ ++# Define the identity of the package. ++ PACKAGE=gc ++ VERSION=6.1a1 ++ ++ ++# Some tools Automake needs. ++ ++ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"} ++ ++ ++AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"} ++ ++ ++AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"} ++ ++ ++AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"} ++ ++ ++MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"} ++ ++ ++AMTAR=${AMTAR-"${am_missing_run}tar"} ++ ++install_sh=${install_sh-"$am_aux_dir/install-sh"} ++ ++# Installed binaries are usually stripped using `strip' when the user ++# run `make install-strip'. However `strip' might not be the right ++# tool to use in cross-compilation environments, therefore Automake ++# will honor the `STRIP' environment variable to overrule this program. ++if test "$cross_compiling" != no; then ++ if test -n "$ac_tool_prefix"; then ++ # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args. ++set dummy ${ac_tool_prefix}strip; ac_word=$2 ++echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 ++if test "${ac_cv_prog_STRIP+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$STRIP"; then ++ ac_cv_prog_STRIP="$STRIP" # Let the user override the test. ++else ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ++ ac_cv_prog_STRIP="${ac_tool_prefix}strip" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++ ++fi ++fi ++STRIP=$ac_cv_prog_STRIP ++if test -n "$STRIP"; then ++ echo "$as_me:$LINENO: result: $STRIP" >&5 ++echo "${ECHO_T}$STRIP" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++fi ++if test -z "$ac_cv_prog_STRIP"; then ++ ac_ct_STRIP=$STRIP ++ # Extract the first word of "strip", so it can be a program name with args. ++set dummy strip; ac_word=$2 ++echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 ++if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$ac_ct_STRIP"; then ++ ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test. ++else ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ++ ac_cv_prog_ac_ct_STRIP="strip" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++ ++ test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":" ++fi ++fi ++ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP ++if test -n "$ac_ct_STRIP"; then ++ echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5 ++echo "${ECHO_T}$ac_ct_STRIP" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++ STRIP=$ac_ct_STRIP ++else ++ STRIP="$ac_cv_prog_STRIP" ++fi ++ ++fi ++INSTALL_STRIP_PROGRAM="\${SHELL} \$(install_sh) -c -s" ++ ++# We need awk for the "check" target. The system "awk" is bad on ++# some platforms. ++ ++ ++ ++ ++# AC_CHECK_TOOL does AC_REQUIRE (AC_CANONICAL_BUILD). If we don't ++# run it explicitly here, it will be run implicitly before ++# NEWLIB_CONFIGURE, which doesn't work because that means that it will ++# be run before AC_CANONICAL_HOST. ++ ++ ++if test -n "$ac_tool_prefix"; then ++ # Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args. ++set dummy ${ac_tool_prefix}as; ac_word=$2 ++echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 ++if test "${ac_cv_prog_AS+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$AS"; then ++ ac_cv_prog_AS="$AS" # Let the user override the test. ++else ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ++ ac_cv_prog_AS="${ac_tool_prefix}as" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++ ++fi ++fi ++AS=$ac_cv_prog_AS ++if test -n "$AS"; then ++ echo "$as_me:$LINENO: result: $AS" >&5 ++echo "${ECHO_T}$AS" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++fi ++if test -z "$ac_cv_prog_AS"; then ++ ac_ct_AS=$AS ++ # Extract the first word of "as", so it can be a program name with args. ++set dummy as; ac_word=$2 ++echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 ++if test "${ac_cv_prog_ac_ct_AS+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$ac_ct_AS"; then ++ ac_cv_prog_ac_ct_AS="$ac_ct_AS" # Let the user override the test. ++else ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ++ ac_cv_prog_ac_ct_AS="as" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++ ++fi ++fi ++ac_ct_AS=$ac_cv_prog_ac_ct_AS ++if test -n "$ac_ct_AS"; then ++ echo "$as_me:$LINENO: result: $ac_ct_AS" >&5 ++echo "${ECHO_T}$ac_ct_AS" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++ AS=$ac_ct_AS ++else ++ AS="$ac_cv_prog_AS" ++fi ++ ++if test -n "$ac_tool_prefix"; then ++ # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args. ++set dummy ${ac_tool_prefix}ar; ac_word=$2 ++echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 ++if test "${ac_cv_prog_AR+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$AR"; then ++ ac_cv_prog_AR="$AR" # Let the user override the test. ++else ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ++ ac_cv_prog_AR="${ac_tool_prefix}ar" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++ ++fi ++fi ++AR=$ac_cv_prog_AR ++if test -n "$AR"; then ++ echo "$as_me:$LINENO: result: $AR" >&5 ++echo "${ECHO_T}$AR" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++fi ++if test -z "$ac_cv_prog_AR"; then ++ ac_ct_AR=$AR ++ # Extract the first word of "ar", so it can be a program name with args. ++set dummy ar; ac_word=$2 ++echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 ++if test "${ac_cv_prog_ac_ct_AR+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$ac_ct_AR"; then ++ ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test. ++else ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ++ ac_cv_prog_ac_ct_AR="ar" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++ ++fi ++fi ++ac_ct_AR=$ac_cv_prog_ac_ct_AR ++if test -n "$ac_ct_AR"; then ++ echo "$as_me:$LINENO: result: $ac_ct_AR" >&5 ++echo "${ECHO_T}$ac_ct_AR" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++ AR=$ac_ct_AR ++else ++ AR="$ac_cv_prog_AR" ++fi ++ ++if test -n "$ac_tool_prefix"; then ++ # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args. ++set dummy ${ac_tool_prefix}ranlib; ac_word=$2 ++echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 ++if test "${ac_cv_prog_RANLIB+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$RANLIB"; then ++ ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test. ++else ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ++ ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++ ++fi ++fi ++RANLIB=$ac_cv_prog_RANLIB ++if test -n "$RANLIB"; then ++ echo "$as_me:$LINENO: result: $RANLIB" >&5 ++echo "${ECHO_T}$RANLIB" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++fi ++if test -z "$ac_cv_prog_RANLIB"; then ++ ac_ct_RANLIB=$RANLIB ++ # Extract the first word of "ranlib", so it can be a program name with args. ++set dummy ranlib; ac_word=$2 ++echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 ++if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$ac_ct_RANLIB"; then ++ ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test. ++else ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ++ ac_cv_prog_ac_ct_RANLIB="ranlib" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++ ++ test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":" ++fi ++fi ++ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB ++if test -n "$ac_ct_RANLIB"; then ++ echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5 ++echo "${ECHO_T}$ac_ct_RANLIB" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++ RANLIB=$ac_ct_RANLIB ++else ++ RANLIB="$ac_cv_prog_RANLIB" ++fi ++ ++ ++# Find a good install program. We prefer a C program (faster), ++# so one script is as good as another. But avoid the broken or ++# incompatible versions: ++# SysV /etc/install, /usr/sbin/install ++# SunOS /usr/etc/install ++# IRIX /sbin/install ++# AIX /bin/install ++# AmigaOS /C/install, which installs bootblocks on floppy discs ++# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag ++# AFS /usr/afsws/bin/install, which mishandles nonexistent args ++# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff" ++# ./install, which can be erroneously created by make from ./install.sh. ++echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5 ++echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6 ++if test -z "$INSTALL"; then ++if test "${ac_cv_path_install+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ # Account for people who put trailing slashes in PATH elements. ++case $as_dir/ in ++ ./ | .// | /cC/* | \ ++ /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \ ++ /usr/ucb/* ) ;; ++ *) ++ # OSF1 and SCO ODT 3.0 have their own names for install. ++ # Don't use installbsd from OSF since it installs stuff as root ++ # by default. ++ for ac_prog in ginstall scoinst install; do ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then ++ if test $ac_prog = install && ++ grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then ++ # AIX install. It has an incompatible calling convention. ++ : ++ elif test $ac_prog = install && ++ grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then ++ # program-specific install script used by HP pwplus--don't use. ++ : ++ else ++ ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c" ++ break 3 ++ fi ++ fi ++ done ++ done ++ ;; ++esac ++done ++ ++ ++fi ++ if test "${ac_cv_path_install+set}" = set; then ++ INSTALL=$ac_cv_path_install ++ else ++ # As a last resort, use the slow shell script. We don't cache a ++ # path for INSTALL within a source directory, because that will ++ # break other packages using the cache if that directory is ++ # removed, or if the path is relative. ++ INSTALL=$ac_install_sh ++ fi ++fi ++echo "$as_me:$LINENO: result: $INSTALL" >&5 ++echo "${ECHO_T}$INSTALL" >&6 ++ ++# Use test -z because SunOS4 sh mishandles braces in ${var-val}. ++# It thinks the first close brace ends the variable substitution. ++test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}' ++ ++test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}' ++ ++test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644' ++ ++ ++echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5 ++echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6 ++ # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given. ++if test "${enable_maintainer_mode+set}" = set; then ++ enableval="$enable_maintainer_mode" ++ USE_MAINTAINER_MODE=$enableval ++else ++ USE_MAINTAINER_MODE=no ++fi; ++ echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5 ++echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6 ++ ++ ++if test $USE_MAINTAINER_MODE = yes; then ++ MAINTAINER_MODE_TRUE= ++ MAINTAINER_MODE_FALSE='#' ++else ++ MAINTAINER_MODE_TRUE='#' ++ MAINTAINER_MODE_FALSE= ++fi ++ ++ MAINT=$MAINTAINER_MODE_TRUE ++ ++ ++ ++# We need AC_EXEEXT to keep automake happy in cygnus mode. However, ++# at least currently, we never actually build a program, so we never ++# need to use $(EXEEXT). Moreover, the test for EXEEXT normally ++# fails, because we are probably configuring with a cross compiler ++# which can't create executables. So we include AC_EXEEXT to keep ++# automake happy, but we don't execute it, since we don't care about ++# the result. ++if false; then ++ # autoconf 2.50 runs AC_EXEEXT by default, and the macro expands ++ # to nothing, so nothing would remain between `then' and `fi' if it ++ # were not for the `:' below. ++ : ++ ++fi ++ ++. ${srcdir}/configure.host ++ ++case ${gc_basedir} in ++/* | A-Za-z:/\\*) gc_flagbasedir=${gc_basedir} ;; ++*) gc_flagbasedir='$(top_builddir)/'${gc_basedir} ;; ++esac ++ ++gc_cflags="${gc_cflags} -I"'$(top_builddir)'"/./targ-include -I${gc_flagbasedir}/libc/include" ++case "${host}" in ++ *-*-cygwin32*) ++ gc_cflags="${gc_cflags} -I${gc_flagbasedir}/../winsup/include" ++ ;; ++esac ++ ++ ++GC_CFLAGS=${gc_cflags} ++ ++ ++ ++# Check whether --enable-shared or --disable-shared was given. ++if test "${enable_shared+set}" = set; then ++ enableval="$enable_shared" ++ p=${PACKAGE-default} ++case $enableval in ++yes) enable_shared=yes ;; ++no) enable_shared=no ;; ++*) ++ enable_shared=no ++ # Look at the argument we got. We use all the common list separators. ++ IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:," ++ for pkg in $enableval; do ++ if test "X$pkg" = "X$p"; then ++ enable_shared=yes ++ fi ++ done ++ IFS="$ac_save_ifs" ++ ;; ++esac ++else ++ enable_shared=yes ++fi; ++# Check whether --enable-static or --disable-static was given. ++if test "${enable_static+set}" = set; then ++ enableval="$enable_static" ++ p=${PACKAGE-default} ++case $enableval in ++yes) enable_static=yes ;; ++no) enable_static=no ;; ++*) ++ enable_static=no ++ # Look at the argument we got. We use all the common list separators. ++ IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:," ++ for pkg in $enableval; do ++ if test "X$pkg" = "X$p"; then ++ enable_static=yes ++ fi ++ done ++ IFS="$ac_save_ifs" ++ ;; ++esac ++else ++ enable_static=yes ++fi; ++# Check whether --enable-fast-install or --disable-fast-install was given. ++if test "${enable_fast_install+set}" = set; then ++ enableval="$enable_fast_install" ++ p=${PACKAGE-default} ++case $enableval in ++yes) enable_fast_install=yes ;; ++no) enable_fast_install=no ;; ++*) ++ enable_fast_install=no ++ # Look at the argument we got. We use all the common list separators. ++ IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:," ++ for pkg in $enableval; do ++ if test "X$pkg" = "X$p"; then ++ enable_fast_install=yes ++ fi ++ done ++ IFS="$ac_save_ifs" ++ ;; ++esac ++else ++ enable_fast_install=yes ++fi; ++rm -f .deps 2>/dev/null ++mkdir .deps 2>/dev/null ++if test -d .deps; then ++ DEPDIR=.deps ++else ++ # MS-DOS does not allow filenames that begin with a dot. ++ DEPDIR=_deps ++fi ++rmdir .deps 2>/dev/null ++ ++ ++ ac_config_commands="$ac_config_commands depfiles" ++ ++ ++am_make=${MAKE-make} ++cat > confinc << 'END' ++doit: ++ @echo done ++END ++# If we don't find an include directive, just comment out the code. ++echo "$as_me:$LINENO: checking for style of include used by $am_make" >&5 ++echo $ECHO_N "checking for style of include used by $am_make... $ECHO_C" >&6 ++am__include="#" ++am__quote= ++_am_result=none ++# First try GNU make style include. ++echo "include confinc" > confmf ++# We grep out `Entering directory' and `Leaving directory' ++# messages which can occur if `w' ends up in MAKEFLAGS. ++# In particular we don't look at `^make:' because GNU make might ++# be invoked under some other name (usually "gmake"), in which ++# case it prints its new name instead of `make'. ++if test "`$am_make -s -f confmf 2> /dev/null | fgrep -v 'ing directory'`" = "done"; then ++ am__include=include ++ am__quote= ++ _am_result=GNU ++fi ++# Now try BSD make style include. ++if test "$am__include" = "#"; then ++ echo '.include "confinc"' > confmf ++ if test "`$am_make -s -f confmf 2> /dev/null`" = "done"; then ++ am__include=.include ++ am__quote="\"" ++ _am_result=BSD ++ fi ++fi ++ ++ ++echo "$as_me:$LINENO: result: $_am_result" >&5 ++echo "${ECHO_T}$_am_result" >&6 ++rm -f confinc confmf ++ ++# Check whether --enable-dependency-tracking or --disable-dependency-tracking was given. ++if test "${enable_dependency_tracking+set}" = set; then ++ enableval="$enable_dependency_tracking" ++ ++fi; ++if test "x$enable_dependency_tracking" != xno; then ++ am_depcomp="$ac_aux_dir/depcomp" ++ AMDEPBACKSLASH='\' ++fi ++ ++ ++if test "x$enable_dependency_tracking" != xno; then ++ AMDEP_TRUE= ++ AMDEP_FALSE='#' ++else ++ AMDEP_TRUE='#' ++ AMDEP_FALSE= ++fi ++ ++ ++ ++ac_ext=c ++ac_cpp='$CPP $CPPFLAGS' ++ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ++ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ++ac_compiler_gnu=$ac_cv_c_compiler_gnu ++if test -n "$ac_tool_prefix"; then ++ # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args. ++set dummy ${ac_tool_prefix}gcc; ac_word=$2 ++echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 ++if test "${ac_cv_prog_CC+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$CC"; then ++ ac_cv_prog_CC="$CC" # Let the user override the test. ++else ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ++ ac_cv_prog_CC="${ac_tool_prefix}gcc" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++ ++fi ++fi ++CC=$ac_cv_prog_CC ++if test -n "$CC"; then ++ echo "$as_me:$LINENO: result: $CC" >&5 ++echo "${ECHO_T}$CC" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++fi ++if test -z "$ac_cv_prog_CC"; then ++ ac_ct_CC=$CC ++ # Extract the first word of "gcc", so it can be a program name with args. ++set dummy gcc; ac_word=$2 ++echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 ++if test "${ac_cv_prog_ac_ct_CC+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$ac_ct_CC"; then ++ ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. ++else ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ++ ac_cv_prog_ac_ct_CC="gcc" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++ ++fi ++fi ++ac_ct_CC=$ac_cv_prog_ac_ct_CC ++if test -n "$ac_ct_CC"; then ++ echo "$as_me:$LINENO: result: $ac_ct_CC" >&5 ++echo "${ECHO_T}$ac_ct_CC" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++ CC=$ac_ct_CC ++else ++ CC="$ac_cv_prog_CC" ++fi ++ ++if test -z "$CC"; then ++ if test -n "$ac_tool_prefix"; then ++ # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args. ++set dummy ${ac_tool_prefix}cc; ac_word=$2 ++echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 ++if test "${ac_cv_prog_CC+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$CC"; then ++ ac_cv_prog_CC="$CC" # Let the user override the test. ++else ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ++ ac_cv_prog_CC="${ac_tool_prefix}cc" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++ ++fi ++fi ++CC=$ac_cv_prog_CC ++if test -n "$CC"; then ++ echo "$as_me:$LINENO: result: $CC" >&5 ++echo "${ECHO_T}$CC" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++fi ++if test -z "$ac_cv_prog_CC"; then ++ ac_ct_CC=$CC ++ # Extract the first word of "cc", so it can be a program name with args. ++set dummy cc; ac_word=$2 ++echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 ++if test "${ac_cv_prog_ac_ct_CC+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$ac_ct_CC"; then ++ ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. ++else ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ++ ac_cv_prog_ac_ct_CC="cc" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++ ++fi ++fi ++ac_ct_CC=$ac_cv_prog_ac_ct_CC ++if test -n "$ac_ct_CC"; then ++ echo "$as_me:$LINENO: result: $ac_ct_CC" >&5 ++echo "${ECHO_T}$ac_ct_CC" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++ CC=$ac_ct_CC ++else ++ CC="$ac_cv_prog_CC" ++fi ++ ++fi ++if test -z "$CC"; then ++ # Extract the first word of "cc", so it can be a program name with args. ++set dummy cc; ac_word=$2 ++echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 ++if test "${ac_cv_prog_CC+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$CC"; then ++ ac_cv_prog_CC="$CC" # Let the user override the test. ++else ++ ac_prog_rejected=no ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ++ if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then ++ ac_prog_rejected=yes ++ continue ++ fi ++ ac_cv_prog_CC="cc" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++ ++if test $ac_prog_rejected = yes; then ++ # We found a bogon in the path, so make sure we never use it. ++ set dummy $ac_cv_prog_CC ++ shift ++ if test $@%:@ != 0; then ++ # We chose a different compiler from the bogus one. ++ # However, it has the same basename, so the bogon will be chosen ++ # first if we set CC to just the basename; use the full file name. ++ shift ++ ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@" ++ fi ++fi ++fi ++fi ++CC=$ac_cv_prog_CC ++if test -n "$CC"; then ++ echo "$as_me:$LINENO: result: $CC" >&5 ++echo "${ECHO_T}$CC" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++fi ++if test -z "$CC"; then ++ if test -n "$ac_tool_prefix"; then ++ for ac_prog in cl ++ do ++ # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. ++set dummy $ac_tool_prefix$ac_prog; ac_word=$2 ++echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 ++if test "${ac_cv_prog_CC+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$CC"; then ++ ac_cv_prog_CC="$CC" # Let the user override the test. ++else ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ++ ac_cv_prog_CC="$ac_tool_prefix$ac_prog" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++ ++fi ++fi ++CC=$ac_cv_prog_CC ++if test -n "$CC"; then ++ echo "$as_me:$LINENO: result: $CC" >&5 ++echo "${ECHO_T}$CC" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++ test -n "$CC" && break ++ done ++fi ++if test -z "$CC"; then ++ ac_ct_CC=$CC ++ for ac_prog in cl ++do ++ # Extract the first word of "$ac_prog", so it can be a program name with args. ++set dummy $ac_prog; ac_word=$2 ++echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 ++if test "${ac_cv_prog_ac_ct_CC+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$ac_ct_CC"; then ++ ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. ++else ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ++ ac_cv_prog_ac_ct_CC="$ac_prog" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++ ++fi ++fi ++ac_ct_CC=$ac_cv_prog_ac_ct_CC ++if test -n "$ac_ct_CC"; then ++ echo "$as_me:$LINENO: result: $ac_ct_CC" >&5 ++echo "${ECHO_T}$ac_ct_CC" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++ test -n "$ac_ct_CC" && break ++done ++ ++ CC=$ac_ct_CC ++fi ++ ++fi ++ ++ ++test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH" >&5 ++echo "$as_me: error: no acceptable C compiler found in \$PATH" >&2;} ++ { (exit 1); exit 1; }; } ++ ++# Provide some information about the compiler. ++echo "$as_me:$LINENO:" \ ++ "checking for C compiler version" >&5 ++ac_compiler=`set X $ac_compile; echo $2` ++{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version &5\"") >&5 ++ (eval $ac_compiler --version &5) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } ++{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v &5\"") >&5 ++ (eval $ac_compiler -v &5) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } ++{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V &5\"") >&5 ++ (eval $ac_compiler -V &5) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } ++ ++cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++#include "confdefs.h" ++ ++int ++main () ++{ ++ ++ ; ++ return 0; ++} ++_ACEOF ++ac_clean_files_save=$ac_clean_files ++ac_clean_files="$ac_clean_files a.out a.exe" ++# Try to create an executable without -o first, disregard a.out. ++# It will help us diagnose broken compilers, and finding out an intuition ++# of exeext. ++echo "$as_me:$LINENO: checking for C compiler default output" >&5 ++echo $ECHO_N "checking for C compiler default output... $ECHO_C" >&6 ++ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'` ++if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5 ++ (eval $ac_link_default) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; then ++ # Find the output, starting from the most likely. This scheme is ++# not robust to junk in `.', hence go to wildcards (a.*) only as a last ++# resort. ++ ++# Be careful to initialize this variable, since it used to be cached. ++# Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile. ++ac_cv_exeext= ++for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.*; do ++ test -f "$ac_file" || continue ++ case $ac_file in ++ *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;; ++ a.out ) # We found the default executable, but exeext='' is most ++ # certainly right. ++ break;; ++ *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` ++ # FIXME: I believe we export ac_cv_exeext for Libtool --akim. ++ export ac_cv_exeext ++ break;; ++ * ) break;; ++ esac ++done ++else ++ echo "$as_me: failed program was:" >&5 ++cat conftest.$ac_ext >&5 ++{ { echo "$as_me:$LINENO: error: C compiler cannot create executables ++check \`config.log' for details." >&5 ++echo "$as_me: error: C compiler cannot create executables ++check \`config.log' for details." >&2;} ++ { (exit 77); exit 77; }; } ++fi ++ ++ac_exeext=$ac_cv_exeext ++echo "$as_me:$LINENO: result: $ac_file" >&5 ++echo "${ECHO_T}$ac_file" >&6 ++ ++# Check the compiler produces executables we can run. If not, either ++# the compiler is broken, or we cross compile. ++echo "$as_me:$LINENO: checking whether the C compiler works" >&5 ++echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6 ++# FIXME: These cross compiler hacks should be removed for Autoconf 3.0 ++# If not cross compiling, check that we can run a simple program. ++if test "$cross_compiling" != yes; then ++ if { ac_try='./$ac_file' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ cross_compiling=no ++ else ++ if test "$cross_compiling" = maybe; then ++ cross_compiling=yes ++ else ++ { { echo "$as_me:$LINENO: error: cannot run C compiled programs. ++If you meant to cross compile, use \`--host'." >&5 ++echo "$as_me: error: cannot run C compiled programs. ++If you meant to cross compile, use \`--host'." >&2;} ++ { (exit 1); exit 1; }; } ++ fi ++ fi ++fi ++echo "$as_me:$LINENO: result: yes" >&5 ++echo "${ECHO_T}yes" >&6 ++ ++rm -f a.out a.exe conftest$ac_cv_exeext ++ac_clean_files=$ac_clean_files_save ++# Check the compiler produces executables we can run. If not, either ++# the compiler is broken, or we cross compile. ++echo "$as_me:$LINENO: checking whether we are cross compiling" >&5 ++echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6 ++echo "$as_me:$LINENO: result: $cross_compiling" >&5 ++echo "${ECHO_T}$cross_compiling" >&6 ++ ++echo "$as_me:$LINENO: checking for suffix of executables" >&5 ++echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6 ++if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 ++ (eval $ac_link) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; then ++ # If both `conftest.exe' and `conftest' are `present' (well, observable) ++# catch `conftest.exe'. For instance with Cygwin, `ls conftest' will ++# work properly (i.e., refer to `conftest.exe'), while it won't with ++# `rm'. ++for ac_file in conftest.exe conftest conftest.*; do ++ test -f "$ac_file" || continue ++ case $ac_file in ++ *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;; ++ *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` ++ export ac_cv_exeext ++ break;; ++ * ) break;; ++ esac ++done ++else ++ { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link" >&5 ++echo "$as_me: error: cannot compute suffix of executables: cannot compile and link" >&2;} ++ { (exit 1); exit 1; }; } ++fi ++ ++rm -f conftest$ac_cv_exeext ++echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5 ++echo "${ECHO_T}$ac_cv_exeext" >&6 ++ ++rm -f conftest.$ac_ext ++EXEEXT=$ac_cv_exeext ++ac_exeext=$EXEEXT ++echo "$as_me:$LINENO: checking for suffix of object files" >&5 ++echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6 ++if test "${ac_cv_objext+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++#include "confdefs.h" ++ ++int ++main () ++{ ++ ++ ; ++ return 0; ++} ++_ACEOF ++rm -f conftest.o conftest.obj ++if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 ++ (eval $ac_compile) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; then ++ for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do ++ case $ac_file in ++ *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;; ++ *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'` ++ break;; ++ esac ++done ++else ++ echo "$as_me: failed program was:" >&5 ++cat conftest.$ac_ext >&5 ++{ { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile" >&5 ++echo "$as_me: error: cannot compute suffix of object files: cannot compile" >&2;} ++ { (exit 1); exit 1; }; } ++fi ++ ++rm -f conftest.$ac_cv_objext conftest.$ac_ext ++fi ++echo "$as_me:$LINENO: result: $ac_cv_objext" >&5 ++echo "${ECHO_T}$ac_cv_objext" >&6 ++OBJEXT=$ac_cv_objext ++ac_objext=$OBJEXT ++echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5 ++echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6 ++if test "${ac_cv_c_compiler_gnu+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++#include "confdefs.h" ++ ++int ++main () ++{ ++#ifndef __GNUC__ ++ choke me ++#endif ++ ++ ; ++ return 0; ++} ++_ACEOF ++rm -f conftest.$ac_objext ++if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 ++ (eval $ac_compile) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && ++ { ac_try='test -s conftest.$ac_objext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ ac_compiler_gnu=yes ++else ++ echo "$as_me: failed program was:" >&5 ++cat conftest.$ac_ext >&5 ++ac_compiler_gnu=no ++fi ++rm -f conftest.$ac_objext conftest.$ac_ext ++ac_cv_c_compiler_gnu=$ac_compiler_gnu ++ ++fi ++echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5 ++echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6 ++GCC=`test $ac_compiler_gnu = yes && echo yes` ++ac_test_CFLAGS=${CFLAGS+set} ++ac_save_CFLAGS=$CFLAGS ++CFLAGS="-g" ++echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5 ++echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6 ++if test "${ac_cv_prog_cc_g+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++#include "confdefs.h" ++ ++int ++main () ++{ ++ ++ ; ++ return 0; ++} ++_ACEOF ++rm -f conftest.$ac_objext ++if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 ++ (eval $ac_compile) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && ++ { ac_try='test -s conftest.$ac_objext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ ac_cv_prog_cc_g=yes ++else ++ echo "$as_me: failed program was:" >&5 ++cat conftest.$ac_ext >&5 ++ac_cv_prog_cc_g=no ++fi ++rm -f conftest.$ac_objext conftest.$ac_ext ++fi ++echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5 ++echo "${ECHO_T}$ac_cv_prog_cc_g" >&6 ++if test "$ac_test_CFLAGS" = set; then ++ CFLAGS=$ac_save_CFLAGS ++elif test $ac_cv_prog_cc_g = yes; then ++ if test "$GCC" = yes; then ++ CFLAGS="-g -O2" ++ else ++ CFLAGS="-g" ++ fi ++else ++ if test "$GCC" = yes; then ++ CFLAGS="-O2" ++ else ++ CFLAGS= ++ fi ++fi ++echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5 ++echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6 ++if test "${ac_cv_prog_cc_stdc+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ ac_cv_prog_cc_stdc=no ++ac_save_CC=$CC ++cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++#include "confdefs.h" ++#include ++#include ++#include ++#include ++/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ ++struct buf { int x; }; ++FILE * (*rcsopen) (struct buf *, struct stat *, int); ++static char *e (p, i) ++ char **p; ++ int i; ++{ ++ return p[i]; ++} ++static char *f (char * (*g) (char **, int), char **p, ...) ++{ ++ char *s; ++ va_list v; ++ va_start (v,p); ++ s = g (p, va_arg (v,int)); ++ va_end (v); ++ return s; ++} ++int test (int i, double x); ++struct s1 {int (*f) (int a);}; ++struct s2 {int (*f) (double a);}; ++int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); ++int argc; ++char **argv; ++int ++main () ++{ ++return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]; ++ ; ++ return 0; ++} ++_ACEOF ++# Don't try gcc -ansi; that turns off useful extensions and ++# breaks some systems' header files. ++# AIX -qlanglvl=ansi ++# Ultrix and OSF/1 -std1 ++# HP-UX 10.20 and later -Ae ++# HP-UX older versions -Aa -D_HPUX_SOURCE ++# SVR4 -Xc -D__EXTENSIONS__ ++for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" ++do ++ CC="$ac_save_CC $ac_arg" ++ rm -f conftest.$ac_objext ++if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 ++ (eval $ac_compile) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && ++ { ac_try='test -s conftest.$ac_objext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ ac_cv_prog_cc_stdc=$ac_arg ++break ++else ++ echo "$as_me: failed program was:" >&5 ++cat conftest.$ac_ext >&5 ++fi ++rm -f conftest.$ac_objext ++done ++rm -f conftest.$ac_ext conftest.$ac_objext ++CC=$ac_save_CC ++ ++fi ++ ++case "x$ac_cv_prog_cc_stdc" in ++ x|xno) ++ echo "$as_me:$LINENO: result: none needed" >&5 ++echo "${ECHO_T}none needed" >&6 ;; ++ *) ++ echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5 ++echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6 ++ CC="$CC $ac_cv_prog_cc_stdc" ;; ++esac ++ ++# Some people use a C++ compiler to compile C. Since we use `exit', ++# in C++ we need to declare it. In case someone uses the same compiler ++# for both compiling C and C++ we need to have the C++ compiler decide ++# the declaration of exit, since it's the most demanding environment. ++cat >conftest.$ac_ext <<_ACEOF ++@%:@ifndef __cplusplus ++ choke me ++@%:@endif ++_ACEOF ++rm -f conftest.$ac_objext ++if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 ++ (eval $ac_compile) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && ++ { ac_try='test -s conftest.$ac_objext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ for ac_declaration in \ ++ ''\ ++ '#include ' \ ++ 'extern "C" void std::exit (int) throw (); using std::exit;' \ ++ 'extern "C" void std::exit (int); using std::exit;' \ ++ 'extern "C" void exit (int) throw ();' \ ++ 'extern "C" void exit (int);' \ ++ 'void exit (int);' ++do ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++#include "confdefs.h" ++@%:@include ++$ac_declaration ++int ++main () ++{ ++exit (42); ++ ; ++ return 0; ++} ++_ACEOF ++rm -f conftest.$ac_objext ++if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 ++ (eval $ac_compile) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && ++ { ac_try='test -s conftest.$ac_objext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ : ++else ++ echo "$as_me: failed program was:" >&5 ++cat conftest.$ac_ext >&5 ++continue ++fi ++rm -f conftest.$ac_objext conftest.$ac_ext ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++#include "confdefs.h" ++$ac_declaration ++int ++main () ++{ ++exit (42); ++ ; ++ return 0; ++} ++_ACEOF ++rm -f conftest.$ac_objext ++if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 ++ (eval $ac_compile) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && ++ { ac_try='test -s conftest.$ac_objext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ break ++else ++ echo "$as_me: failed program was:" >&5 ++cat conftest.$ac_ext >&5 ++fi ++rm -f conftest.$ac_objext conftest.$ac_ext ++done ++rm -f conftest* ++if test -n "$ac_declaration"; then ++ echo '#ifdef __cplusplus' >>confdefs.h ++ echo $ac_declaration >>confdefs.h ++ echo '#endif' >>confdefs.h ++fi ++ ++else ++ echo "$as_me: failed program was:" >&5 ++cat conftest.$ac_ext >&5 ++fi ++rm -f conftest.$ac_objext conftest.$ac_ext ++ac_ext=c ++ac_cpp='$CPP $CPPFLAGS' ++ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ++ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ++ac_compiler_gnu=$ac_cv_c_compiler_gnu ++ ++depcc="$CC" am_compiler_list= ++ ++echo "$as_me:$LINENO: checking dependency style of $depcc" >&5 ++echo $ECHO_N "checking dependency style of $depcc... $ECHO_C" >&6 ++if test "${am_cv_CC_dependencies_compiler_type+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then ++ # We make a subdir and do the tests there. Otherwise we can end up ++ # making bogus files that we don't know about and never remove. For ++ # instance it was reported that on HP-UX the gcc test will end up ++ # making a dummy file named `D' -- because `-MD' means `put the output ++ # in D'. ++ mkdir conftest.dir ++ # Copy depcomp to subdir because otherwise we won't find it if we're ++ # using a relative directory. ++ cp "$am_depcomp" conftest.dir ++ cd conftest.dir ++ ++ am_cv_CC_dependencies_compiler_type=none ++ if test "$am_compiler_list" = ""; then ++ am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp` ++ fi ++ for depmode in $am_compiler_list; do ++ # We need to recreate these files for each test, as the compiler may ++ # overwrite some of them when testing with obscure command lines. ++ # This happens at least with the AIX C compiler. ++ echo '#include "conftest.h"' > conftest.c ++ echo 'int i;' > conftest.h ++ echo "${am__include} ${am__quote}conftest.Po${am__quote}" > confmf ++ ++ case $depmode in ++ nosideeffect) ++ # after this tag, mechanisms are not by side-effect, so they'll ++ # only be used when explicitly requested ++ if test "x$enable_dependency_tracking" = xyes; then ++ continue ++ else ++ break ++ fi ++ ;; ++ none) break ;; ++ esac ++ # We check with `-c' and `-o' for the sake of the "dashmstdout" ++ # mode. It turns out that the SunPro C++ compiler does not properly ++ # handle `-M -o', and we need to detect this. ++ if depmode=$depmode \ ++ source=conftest.c object=conftest.o \ ++ depfile=conftest.Po tmpdepfile=conftest.TPo \ ++ $SHELL ./depcomp $depcc -c conftest.c -o conftest.o >/dev/null 2>&1 && ++ grep conftest.h conftest.Po > /dev/null 2>&1 && ++ ${MAKE-make} -s -f confmf > /dev/null 2>&1; then ++ am_cv_CC_dependencies_compiler_type=$depmode ++ break ++ fi ++ done ++ ++ cd .. ++ rm -rf conftest.dir ++else ++ am_cv_CC_dependencies_compiler_type=none ++fi ++ ++fi ++echo "$as_me:$LINENO: result: $am_cv_CC_dependencies_compiler_type" >&5 ++echo "${ECHO_T}$am_cv_CC_dependencies_compiler_type" >&6 ++CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type ++ ++ ++# Find the correct PATH separator. Usually this is `:', but ++# DJGPP uses `;' like DOS. ++if test "X${PATH_SEPARATOR+set}" != Xset; then ++ UNAME=${UNAME-`uname 2>/dev/null`} ++ case X$UNAME in ++ *-DOS) lt_cv_sys_path_separator=';' ;; ++ *) lt_cv_sys_path_separator=':' ;; ++ esac ++ PATH_SEPARATOR=$lt_cv_sys_path_separator ++fi ++ ++ ++# Check whether --with-gnu-ld or --without-gnu-ld was given. ++if test "${with_gnu_ld+set}" = set; then ++ withval="$with_gnu_ld" ++ test "$withval" = no || with_gnu_ld=yes ++else ++ with_gnu_ld=no ++fi; ++ac_prog=ld ++if test "$GCC" = yes; then ++ # Check if gcc -print-prog-name=ld gives a path. ++ echo "$as_me:$LINENO: checking for ld used by GCC" >&5 ++echo $ECHO_N "checking for ld used by GCC... $ECHO_C" >&6 ++ case $host in ++ *-*-mingw*) ++ # gcc leaves a trailing carriage return which upsets mingw ++ ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;; ++ *) ++ ac_prog=`($CC -print-prog-name=ld) 2>&5` ;; ++ esac ++ case $ac_prog in ++ # Accept absolute paths. ++ [\\/]* | [A-Za-z]:[\\/]*) ++ re_direlt='/[^/][^/]*/\.\./' ++ # Canonicalize the path of ld ++ ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'` ++ while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do ++ ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"` ++ done ++ test -z "$LD" && LD="$ac_prog" ++ ;; ++ "") ++ # If it fails, then pretend we aren't using GCC. ++ ac_prog=ld ++ ;; ++ *) ++ # If it is relative, then search for the first ld in PATH. ++ with_gnu_ld=unknown ++ ;; ++ esac ++elif test "$with_gnu_ld" = yes; then ++ echo "$as_me:$LINENO: checking for GNU ld" >&5 ++echo $ECHO_N "checking for GNU ld... $ECHO_C" >&6 ++else ++ echo "$as_me:$LINENO: checking for non-GNU ld" >&5 ++echo $ECHO_N "checking for non-GNU ld... $ECHO_C" >&6 ++fi ++if test "${lt_cv_path_LD+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -z "$LD"; then ++ IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS=$PATH_SEPARATOR ++ for ac_dir in $PATH; do ++ test -z "$ac_dir" && ac_dir=. ++ if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then ++ lt_cv_path_LD="$ac_dir/$ac_prog" ++ # Check to see if the program is GNU ld. I'd rather use --version, ++ # but apparently some GNU ld's only accept -v. ++ # Break only if it was the GNU/non-GNU ld that we prefer. ++ if "$lt_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then ++ test "$with_gnu_ld" != no && break ++ else ++ test "$with_gnu_ld" != yes && break ++ fi ++ fi ++ done ++ IFS="$ac_save_ifs" ++else ++ lt_cv_path_LD="$LD" # Let the user override the test with a path. ++fi ++fi ++ ++LD="$lt_cv_path_LD" ++if test -n "$LD"; then ++ echo "$as_me:$LINENO: result: $LD" >&5 ++echo "${ECHO_T}$LD" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++test -z "$LD" && { { echo "$as_me:$LINENO: error: no acceptable ld found in \$PATH" >&5 ++echo "$as_me: error: no acceptable ld found in \$PATH" >&2;} ++ { (exit 1); exit 1; }; } ++echo "$as_me:$LINENO: checking if the linker ($LD) is GNU ld" >&5 ++echo $ECHO_N "checking if the linker ($LD) is GNU ld... $ECHO_C" >&6 ++if test "${lt_cv_prog_gnu_ld+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ # I'd rather use --version here, but apparently some GNU ld's only accept -v. ++if $LD -v 2>&1 &5; then ++ lt_cv_prog_gnu_ld=yes ++else ++ lt_cv_prog_gnu_ld=no ++fi ++fi ++echo "$as_me:$LINENO: result: $lt_cv_prog_gnu_ld" >&5 ++echo "${ECHO_T}$lt_cv_prog_gnu_ld" >&6 ++with_gnu_ld=$lt_cv_prog_gnu_ld ++ ++ ++echo "$as_me:$LINENO: checking for $LD option to reload object files" >&5 ++echo $ECHO_N "checking for $LD option to reload object files... $ECHO_C" >&6 ++if test "${lt_cv_ld_reload_flag+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ lt_cv_ld_reload_flag='-r' ++fi ++echo "$as_me:$LINENO: result: $lt_cv_ld_reload_flag" >&5 ++echo "${ECHO_T}$lt_cv_ld_reload_flag" >&6 ++reload_flag=$lt_cv_ld_reload_flag ++test -n "$reload_flag" && reload_flag=" $reload_flag" ++ ++echo "$as_me:$LINENO: checking for BSD-compatible nm" >&5 ++echo $ECHO_N "checking for BSD-compatible nm... $ECHO_C" >&6 ++if test "${lt_cv_path_NM+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$NM"; then ++ # Let the user override the test. ++ lt_cv_path_NM="$NM" ++else ++ IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS=$PATH_SEPARATOR ++ for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do ++ test -z "$ac_dir" && ac_dir=. ++ tmp_nm=$ac_dir/${ac_tool_prefix}nm ++ if test -f $tmp_nm || test -f $tmp_nm$ac_exeext ; then ++ # Check to see if the nm accepts a BSD-compat flag. ++ # Adding the `sed 1q' prevents false positives on HP-UX, which says: ++ # nm: unknown option "B" ignored ++ # Tru64's nm complains that /dev/null is an invalid object file ++ if ($tmp_nm -B /dev/null 2>&1 | sed '1q'; exit 0) | egrep '(/dev/null|Invalid file or object type)' >/dev/null; then ++ lt_cv_path_NM="$tmp_nm -B" ++ break ++ elif ($tmp_nm -p /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then ++ lt_cv_path_NM="$tmp_nm -p" ++ break ++ else ++ lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but ++ continue # so that we can try to find one that supports BSD flags ++ fi ++ fi ++ done ++ IFS="$ac_save_ifs" ++ test -z "$lt_cv_path_NM" && lt_cv_path_NM=nm ++fi ++fi ++ ++NM="$lt_cv_path_NM" ++echo "$as_me:$LINENO: result: $NM" >&5 ++echo "${ECHO_T}$NM" >&6 ++ ++echo "$as_me:$LINENO: checking whether ln -s works" >&5 ++echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6 ++LN_S=$as_ln_s ++if test "$LN_S" = "ln -s"; then ++ echo "$as_me:$LINENO: result: yes" >&5 ++echo "${ECHO_T}yes" >&6 ++else ++ echo "$as_me:$LINENO: result: no, using $LN_S" >&5 ++echo "${ECHO_T}no, using $LN_S" >&6 ++fi ++ ++echo "$as_me:$LINENO: checking how to recognise dependant libraries" >&5 ++echo $ECHO_N "checking how to recognise dependant libraries... $ECHO_C" >&6 ++if test "${lt_cv_deplibs_check_method+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ lt_cv_file_magic_cmd='$MAGIC_CMD' ++lt_cv_file_magic_test_file= ++lt_cv_deplibs_check_method='unknown' ++# Need to set the preceding variable on all platforms that support ++# interlibrary dependencies. ++# 'none' -- dependencies not supported. ++# `unknown' -- same as none, but documents that we really don't know. ++# 'pass_all' -- all dependencies passed with no checks. ++# 'test_compile' -- check by making test program. ++# 'file_magic [[regex]]' -- check by looking for files in library path ++# which responds to the $file_magic_cmd with a given egrep regex. ++# If you have `file' or equivalent on your system and you're not sure ++# whether `pass_all' will *always* work, you probably want this one. ++ ++case $host_os in ++aix4* | aix5*) ++ lt_cv_deplibs_check_method=pass_all ++ ;; ++ ++beos*) ++ lt_cv_deplibs_check_method=pass_all ++ ;; ++ ++bsdi4*) ++ lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)' ++ lt_cv_file_magic_cmd='/usr/bin/file -L' ++ lt_cv_file_magic_test_file=/shlib/libc.so ++ ;; ++ ++cygwin* | mingw* | pw32*) ++ lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?' ++ lt_cv_file_magic_cmd='$OBJDUMP -f' ++ ;; ++ ++darwin* | rhapsody*) ++ lt_cv_deplibs_check_method='file_magic Mach-O dynamically linked shared library' ++ lt_cv_file_magic_cmd='/usr/bin/file -L' ++ case "$host_os" in ++ rhapsody* | darwin1.[012]) ++ lt_cv_file_magic_test_file='/System/Library/Frameworks/System.framework/System' ++ ;; ++ *) # Darwin 1.3 on ++ lt_cv_file_magic_test_file='/usr/lib/libSystem.dylib' ++ ;; ++ esac ++ ;; ++ ++freebsd*) ++ if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then ++ case $host_cpu in ++ i*86 ) ++ # Not sure whether the presence of OpenBSD here was a mistake. ++ # Let's accept both of them until this is cleared up. ++ lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD)/i[3-9]86 (compact )?demand paged shared library' ++ lt_cv_file_magic_cmd=/usr/bin/file ++ lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*` ++ ;; ++ esac ++ else ++ lt_cv_deplibs_check_method=pass_all ++ fi ++ ;; ++ ++gnu*) ++ lt_cv_deplibs_check_method=pass_all ++ ;; ++ ++hpux10.20*|hpux11*) ++ lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9].[0-9]) shared library' ++ lt_cv_file_magic_cmd=/usr/bin/file ++ lt_cv_file_magic_test_file=/usr/lib/libc.sl ++ ;; ++ ++irix5* | irix6*) ++ case $host_os in ++ irix5*) ++ # this will be overridden with pass_all, but let us keep it just in case ++ lt_cv_deplibs_check_method="file_magic ELF 32-bit MSB dynamic lib MIPS - version 1" ++ ;; ++ *) ++ case $LD in ++ *-32|*"-32 ") libmagic=32-bit;; ++ *-n32|*"-n32 ") libmagic=N32;; ++ *-64|*"-64 ") libmagic=64-bit;; ++ *) libmagic=never-match;; ++ esac ++ # this will be overridden with pass_all, but let us keep it just in case ++ lt_cv_deplibs_check_method="file_magic ELF ${libmagic} MSB mips-[1234] dynamic lib MIPS - version 1" ++ ;; ++ esac ++ lt_cv_file_magic_test_file=`echo /lib${libsuff}/libc.so*` ++ lt_cv_deplibs_check_method=pass_all ++ ;; ++ ++# This must be Linux ELF. ++linux-gnu*) ++ case $host_cpu in ++ alpha* | hppa* | i*86 | powerpc* | sparc* | ia64* ) ++ lt_cv_deplibs_check_method=pass_all ;; ++ *) ++ # glibc up to 2.1.1 does not perform some relocations on ARM ++ lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB (shared object|dynamic lib )' ;; ++ esac ++ lt_cv_file_magic_test_file=`echo /lib/libc.so* /lib/libc-*.so` ++ ;; ++ ++netbsd*) ++ if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then ++ lt_cv_deplibs_check_method='match_pattern /lib[^/\.]+\.so\.[0-9]+\.[0-9]+$' ++ else ++ lt_cv_deplibs_check_method='match_pattern /lib[^/\.]+\.so$' ++ fi ++ ;; ++ ++newos6*) ++ lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (executable|dynamic lib)' ++ lt_cv_file_magic_cmd=/usr/bin/file ++ lt_cv_file_magic_test_file=/usr/lib/libnls.so ++ ;; ++ ++openbsd*) ++ lt_cv_file_magic_cmd=/usr/bin/file ++ lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*` ++ if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then ++ lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB shared object' ++ else ++ lt_cv_deplibs_check_method='file_magic OpenBSD.* shared library' ++ fi ++ ;; ++ ++osf3* | osf4* | osf5*) ++ # this will be overridden with pass_all, but let us keep it just in case ++ lt_cv_deplibs_check_method='file_magic COFF format alpha shared library' ++ lt_cv_file_magic_test_file=/shlib/libc.so ++ lt_cv_deplibs_check_method=pass_all ++ ;; ++ ++sco3.2v5*) ++ lt_cv_deplibs_check_method=pass_all ++ ;; ++ ++solaris*) ++ lt_cv_deplibs_check_method=pass_all ++ lt_cv_file_magic_test_file=/lib/libc.so ++ ;; ++ ++sysv5uw[78]* | sysv4*uw2*) ++ lt_cv_deplibs_check_method=pass_all ++ ;; ++ ++sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) ++ case $host_vendor in ++ motorola) ++ lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib) M[0-9][0-9]* Version [0-9]' ++ lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*` ++ ;; ++ ncr) ++ lt_cv_deplibs_check_method=pass_all ++ ;; ++ sequent) ++ lt_cv_file_magic_cmd='/bin/file' ++ lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB (shared object|dynamic lib )' ++ ;; ++ sni) ++ lt_cv_file_magic_cmd='/bin/file' ++ lt_cv_deplibs_check_method="file_magic ELF [0-9][0-9]*-bit [LM]SB dynamic lib" ++ lt_cv_file_magic_test_file=/lib/libc.so ++ ;; ++ esac ++ ;; ++esac ++ ++fi ++echo "$as_me:$LINENO: result: $lt_cv_deplibs_check_method" >&5 ++echo "${ECHO_T}$lt_cv_deplibs_check_method" >&6 ++file_magic_cmd=$lt_cv_file_magic_cmd ++deplibs_check_method=$lt_cv_deplibs_check_method ++ ++ ++ ++ ++ ++ ++ ++# Check for command to grab the raw symbol name followed by C symbol from nm. ++echo "$as_me:$LINENO: checking command to parse $NM output" >&5 ++echo $ECHO_N "checking command to parse $NM output... $ECHO_C" >&6 ++if test "${lt_cv_sys_global_symbol_pipe+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ ++# These are sane defaults that work on at least a few old systems. ++# [They come from Ultrix. What could be older than Ultrix?!! ;)] ++ ++# Character class describing NM global symbol codes. ++symcode='[BCDEGRST]' ++ ++# Regexp to match symbols that can be accessed directly from C. ++sympat='\([_A-Za-z][_A-Za-z0-9]*\)' ++ ++# Transform the above into a raw symbol and a C symbol. ++symxfrm='\1 \2\3 \3' ++ ++# Transform an extracted symbol line into a proper C declaration ++lt_cv_global_symbol_to_cdecl="sed -n -e 's/^. .* \(.*\)$/extern char \1;/p'" ++ ++# Transform an extracted symbol line into symbol name and symbol address ++lt_cv_global_symbol_to_c_name_address="sed -n -e 's/^: \([^ ]*\) $/ {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode \([^ ]*\) \([^ ]*\)$/ {\"\2\", (lt_ptr) \&\2},/p'" ++ ++# Define system-specific variables. ++case $host_os in ++aix*) ++ symcode='[BCDT]' ++ ;; ++cygwin* | mingw* | pw32*) ++ symcode='[ABCDGISTW]' ++ ;; ++hpux*) # Its linker distinguishes data from code symbols ++ lt_cv_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern char \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'" ++ lt_cv_global_symbol_to_c_name_address="sed -n -e 's/^: \([^ ]*\) $/ {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode* \([^ ]*\) \([^ ]*\)$/ {\"\2\", (lt_ptr) \&\2},/p'" ++ ;; ++irix*) ++ symcode='[BCDEGRST]' ++ ;; ++solaris* | sysv5*) ++ symcode='[BDT]' ++ ;; ++sysv4) ++ symcode='[DFNSTU]' ++ ;; ++esac ++ ++# Handle CRLF in mingw tool chain ++opt_cr= ++case $host_os in ++mingw*) ++ opt_cr=`echo 'x\{0,1\}' | tr x '\015'` # option cr in regexp ++ ;; ++esac ++ ++# If we're using GNU nm, then use its standard symbol codes. ++if $NM -V 2>&1 | egrep '(GNU|with BFD)' > /dev/null; then ++ symcode='[ABCDGISTW]' ++fi ++ ++# Try without a prefix undercore, then with it. ++for ac_symprfx in "" "_"; do ++ ++ # Write the raw and C identifiers. ++lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[ ]\($symcode$symcode*\)[ ][ ]*\($ac_symprfx\)$sympat$opt_cr$/$symxfrm/p'" ++ ++ # Check to see that the pipe works correctly. ++ pipe_works=no ++ rm -f conftest* ++ cat > conftest.$ac_ext <&5 ++ (eval $ac_compile) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; then ++ # Now try to grab the symbols. ++ nlist=conftest.nm ++ if { (eval echo "$as_me:$LINENO: \"$NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $nlist\"") >&5 ++ (eval $NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $nlist) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && test -s "$nlist"; then ++ # Try sorting and uniquifying the output. ++ if sort "$nlist" | uniq > "$nlist"T; then ++ mv -f "$nlist"T "$nlist" ++ else ++ rm -f "$nlist"T ++ fi ++ ++ # Make sure that we snagged all the symbols we need. ++ if egrep ' nm_test_var$' "$nlist" >/dev/null; then ++ if egrep ' nm_test_func$' "$nlist" >/dev/null; then ++ cat < conftest.$ac_ext ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++EOF ++ # Now generate the symbol file. ++ eval "$lt_cv_global_symbol_to_cdecl"' < "$nlist" >> conftest.$ac_ext' ++ ++ cat <> conftest.$ac_ext ++#if defined (__STDC__) && __STDC__ ++# define lt_ptr void * ++#else ++# define lt_ptr char * ++# define const ++#endif ++ ++/* The mapping between symbol names and symbols. */ ++const struct { ++ const char *name; ++ lt_ptr address; ++} ++lt_preloaded_symbols[] = ++{ ++EOF ++ sed "s/^$symcode$symcode* \(.*\) \(.*\)$/ {\"\2\", (lt_ptr) \&\2},/" < "$nlist" >> conftest.$ac_ext ++ cat <<\EOF >> conftest.$ac_ext ++ {0, (lt_ptr) 0} ++}; ++ ++#ifdef __cplusplus ++} ++#endif ++EOF ++ # Now try linking the two files. ++ mv conftest.$ac_objext conftstm.$ac_objext ++ save_LIBS="$LIBS" ++ save_CFLAGS="$CFLAGS" ++ LIBS="conftstm.$ac_objext" ++ CFLAGS="$CFLAGS$no_builtin_flag" ++ if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 ++ (eval $ac_link) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && test -s conftest; then ++ pipe_works=yes ++ fi ++ LIBS="$save_LIBS" ++ CFLAGS="$save_CFLAGS" ++ else ++ echo "cannot find nm_test_func in $nlist" >&5 ++ fi ++ else ++ echo "cannot find nm_test_var in $nlist" >&5 ++ fi ++ else ++ echo "cannot run $lt_cv_sys_global_symbol_pipe" >&5 ++ fi ++ else ++ echo "$progname: failed program was:" >&5 ++ cat conftest.$ac_ext >&5 ++ fi ++ rm -f conftest* conftst* ++ ++ # Do not use the global_symbol_pipe unless it works. ++ if test "$pipe_works" = yes; then ++ break ++ else ++ lt_cv_sys_global_symbol_pipe= ++ fi ++done ++ ++fi ++ ++global_symbol_pipe="$lt_cv_sys_global_symbol_pipe" ++if test -z "$lt_cv_sys_global_symbol_pipe"; then ++ global_symbol_to_cdecl= ++ global_symbol_to_c_name_address= ++else ++ global_symbol_to_cdecl="$lt_cv_global_symbol_to_cdecl" ++ global_symbol_to_c_name_address="$lt_cv_global_symbol_to_c_name_address" ++fi ++if test -z "$global_symbol_pipe$global_symbol_to_cdec$global_symbol_to_c_name_address"; ++then ++ echo "$as_me:$LINENO: result: failed" >&5 ++echo "${ECHO_T}failed" >&6 ++else ++ echo "$as_me:$LINENO: result: ok" >&5 ++echo "${ECHO_T}ok" >&6 ++fi ++ ++ac_ext=c ++ac_cpp='$CPP $CPPFLAGS' ++ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ++ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ++ac_compiler_gnu=$ac_cv_c_compiler_gnu ++echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5 ++echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6 ++# On Suns, sometimes $CPP names a directory. ++if test -n "$CPP" && test -d "$CPP"; then ++ CPP= ++fi ++if test -z "$CPP"; then ++ if test "${ac_cv_prog_CPP+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ # Double quotes because CPP needs to be expanded ++ for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp" ++ do ++ ac_preproc_ok=false ++for ac_c_preproc_warn_flag in '' yes ++do ++ # Use a header file that comes with gcc, so configuring glibc ++ # with a fresh cross-compiler works. ++ # On the NeXT, cc -E runs the code through the compiler's parser, ++ # not just through cpp. "Syntax error" is here to catch this case. ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++#include "confdefs.h" ++@%:@include ++ Syntax error ++_ACEOF ++if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 ++ (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 ++ ac_status=$? ++ grep -v '^ *+' conftest.er1 >conftest.err ++ rm -f conftest.er1 ++ cat conftest.err >&5 ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } >/dev/null; then ++ if test -s conftest.err; then ++ ac_cpp_err=$ac_c_preproc_warn_flag ++ else ++ ac_cpp_err= ++ fi ++else ++ ac_cpp_err=yes ++fi ++if test -z "$ac_cpp_err"; then ++ : ++else ++ echo "$as_me: failed program was:" >&5 ++ cat conftest.$ac_ext >&5 ++ # Broken: fails on valid input. ++continue ++fi ++rm -f conftest.err conftest.$ac_ext ++ ++ # OK, works on sane cases. Now check whether non-existent headers ++ # can be detected and how. ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++#include "confdefs.h" ++@%:@include ++_ACEOF ++if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 ++ (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 ++ ac_status=$? ++ grep -v '^ *+' conftest.er1 >conftest.err ++ rm -f conftest.er1 ++ cat conftest.err >&5 ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } >/dev/null; then ++ if test -s conftest.err; then ++ ac_cpp_err=$ac_c_preproc_warn_flag ++ else ++ ac_cpp_err= ++ fi ++else ++ ac_cpp_err=yes ++fi ++if test -z "$ac_cpp_err"; then ++ # Broken: success on invalid input. ++continue ++else ++ echo "$as_me: failed program was:" >&5 ++ cat conftest.$ac_ext >&5 ++ # Passes both tests. ++ac_preproc_ok=: ++break ++fi ++rm -f conftest.err conftest.$ac_ext ++ ++done ++# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. ++rm -f conftest.err conftest.$ac_ext ++if $ac_preproc_ok; then ++ break ++fi ++ ++ done ++ ac_cv_prog_CPP=$CPP ++ ++fi ++ CPP=$ac_cv_prog_CPP ++else ++ ac_cv_prog_CPP=$CPP ++fi ++echo "$as_me:$LINENO: result: $CPP" >&5 ++echo "${ECHO_T}$CPP" >&6 ++ac_preproc_ok=false ++for ac_c_preproc_warn_flag in '' yes ++do ++ # Use a header file that comes with gcc, so configuring glibc ++ # with a fresh cross-compiler works. ++ # On the NeXT, cc -E runs the code through the compiler's parser, ++ # not just through cpp. "Syntax error" is here to catch this case. ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++#include "confdefs.h" ++@%:@include ++ Syntax error ++_ACEOF ++if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 ++ (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 ++ ac_status=$? ++ grep -v '^ *+' conftest.er1 >conftest.err ++ rm -f conftest.er1 ++ cat conftest.err >&5 ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } >/dev/null; then ++ if test -s conftest.err; then ++ ac_cpp_err=$ac_c_preproc_warn_flag ++ else ++ ac_cpp_err= ++ fi ++else ++ ac_cpp_err=yes ++fi ++if test -z "$ac_cpp_err"; then ++ : ++else ++ echo "$as_me: failed program was:" >&5 ++ cat conftest.$ac_ext >&5 ++ # Broken: fails on valid input. ++continue ++fi ++rm -f conftest.err conftest.$ac_ext ++ ++ # OK, works on sane cases. Now check whether non-existent headers ++ # can be detected and how. ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++#include "confdefs.h" ++@%:@include ++_ACEOF ++if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 ++ (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 ++ ac_status=$? ++ grep -v '^ *+' conftest.er1 >conftest.err ++ rm -f conftest.er1 ++ cat conftest.err >&5 ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } >/dev/null; then ++ if test -s conftest.err; then ++ ac_cpp_err=$ac_c_preproc_warn_flag ++ else ++ ac_cpp_err= ++ fi ++else ++ ac_cpp_err=yes ++fi ++if test -z "$ac_cpp_err"; then ++ # Broken: success on invalid input. ++continue ++else ++ echo "$as_me: failed program was:" >&5 ++ cat conftest.$ac_ext >&5 ++ # Passes both tests. ++ac_preproc_ok=: ++break ++fi ++rm -f conftest.err conftest.$ac_ext ++ ++done ++# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. ++rm -f conftest.err conftest.$ac_ext ++if $ac_preproc_ok; then ++ : ++else ++ { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check" >&5 ++echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check" >&2;} ++ { (exit 1); exit 1; }; } ++fi ++ ++ac_ext=c ++ac_cpp='$CPP $CPPFLAGS' ++ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ++ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ++ac_compiler_gnu=$ac_cv_c_compiler_gnu ++ ++ ++echo "$as_me:$LINENO: checking for egrep" >&5 ++echo $ECHO_N "checking for egrep... $ECHO_C" >&6 ++if test "${ac_cv_prog_egrep+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if echo a | (grep -E '(a|b)') >/dev/null 2>&1 ++ then ac_cv_prog_egrep='grep -E' ++ else ac_cv_prog_egrep='egrep' ++ fi ++fi ++echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5 ++echo "${ECHO_T}$ac_cv_prog_egrep" >&6 ++ EGREP=$ac_cv_prog_egrep ++ ++ ++echo "$as_me:$LINENO: checking for ANSI C header files" >&5 ++echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6 ++if test "${ac_cv_header_stdc+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++#include "confdefs.h" ++#include ++#include ++#include ++#include ++ ++_ACEOF ++if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 ++ (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 ++ ac_status=$? ++ grep -v '^ *+' conftest.er1 >conftest.err ++ rm -f conftest.er1 ++ cat conftest.err >&5 ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } >/dev/null; then ++ if test -s conftest.err; then ++ ac_cpp_err=$ac_c_preproc_warn_flag ++ else ++ ac_cpp_err= ++ fi ++else ++ ac_cpp_err=yes ++fi ++if test -z "$ac_cpp_err"; then ++ ac_cv_header_stdc=yes ++else ++ echo "$as_me: failed program was:" >&5 ++ cat conftest.$ac_ext >&5 ++ ac_cv_header_stdc=no ++fi ++rm -f conftest.err conftest.$ac_ext ++ ++if test $ac_cv_header_stdc = yes; then ++ # SunOS 4.x string.h does not declare mem*, contrary to ANSI. ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++#include "confdefs.h" ++#include ++ ++_ACEOF ++if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | ++ $EGREP "memchr" >/dev/null 2>&1; then ++ : ++else ++ ac_cv_header_stdc=no ++fi ++rm -f conftest* ++ ++fi ++ ++if test $ac_cv_header_stdc = yes; then ++ # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++#include "confdefs.h" ++#include ++ ++_ACEOF ++if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | ++ $EGREP "free" >/dev/null 2>&1; then ++ : ++else ++ ac_cv_header_stdc=no ++fi ++rm -f conftest* ++ ++fi ++ ++if test $ac_cv_header_stdc = yes; then ++ # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. ++ if test "$cross_compiling" = yes; then ++ : ++else ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++#include "confdefs.h" ++#include ++#if ((' ' & 0x0FF) == 0x020) ++# define ISLOWER(c) ('a' <= (c) && (c) <= 'z') ++# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) ++#else ++# define ISLOWER(c) (('a' <= (c) && (c) <= 'i') \ ++ || ('j' <= (c) && (c) <= 'r') \ ++ || ('s' <= (c) && (c) <= 'z')) ++# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c)) ++#endif ++ ++#define XOR(e, f) (((e) && !(f)) || (!(e) && (f))) ++int ++main () ++{ ++ int i; ++ for (i = 0; i < 256; i++) ++ if (XOR (islower (i), ISLOWER (i)) ++ || toupper (i) != TOUPPER (i)) ++ exit(2); ++ exit (0); ++} ++_ACEOF ++rm -f conftest$ac_exeext ++if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 ++ (eval $ac_link) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && { ac_try='./conftest$ac_exeext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ : ++else ++ echo "$as_me: program exited with status $ac_status" >&5 ++echo "$as_me: failed program was:" >&5 ++cat conftest.$ac_ext >&5 ++( exit $ac_status ) ++ac_cv_header_stdc=no ++fi ++rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext ++fi ++fi ++fi ++echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5 ++echo "${ECHO_T}$ac_cv_header_stdc" >&6 ++if test $ac_cv_header_stdc = yes; then ++ ++cat >>confdefs.h <<\_ACEOF ++@%:@define STDC_HEADERS 1 ++_ACEOF ++ ++fi ++ ++# On IRIX 5.3, sys/types and inttypes.h are conflicting. ++ ++ ++ ++ ++ ++ ++ ++ ++ ++for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \ ++ inttypes.h stdint.h unistd.h ++do ++as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` ++echo "$as_me:$LINENO: checking for $ac_header" >&5 ++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6 ++if eval "test \"\${$as_ac_Header+set}\" = set"; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++#include "confdefs.h" ++$ac_includes_default ++ ++@%:@include <$ac_header> ++_ACEOF ++rm -f conftest.$ac_objext ++if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 ++ (eval $ac_compile) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && ++ { ac_try='test -s conftest.$ac_objext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ eval "$as_ac_Header=yes" ++else ++ echo "$as_me: failed program was:" >&5 ++cat conftest.$ac_ext >&5 ++eval "$as_ac_Header=no" ++fi ++rm -f conftest.$ac_objext conftest.$ac_ext ++fi ++echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5 ++echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6 ++if test `eval echo '${'$as_ac_Header'}'` = yes; then ++ cat >>confdefs.h <<_ACEOF ++@%:@define `echo "HAVE_$ac_header" | $as_tr_cpp` 1 ++_ACEOF ++ ++fi ++ ++done ++ ++ ++ ++for ac_header in dlfcn.h ++do ++as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` ++if eval "test \"\${$as_ac_Header+set}\" = set"; then ++ echo "$as_me:$LINENO: checking for $ac_header" >&5 ++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6 ++if eval "test \"\${$as_ac_Header+set}\" = set"; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++fi ++echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5 ++echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6 ++else ++ # Is the header compilable? ++echo "$as_me:$LINENO: checking $ac_header usability" >&5 ++echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6 ++cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++#include "confdefs.h" ++$ac_includes_default ++@%:@include <$ac_header> ++_ACEOF ++rm -f conftest.$ac_objext ++if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 ++ (eval $ac_compile) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && ++ { ac_try='test -s conftest.$ac_objext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ ac_header_compiler=yes ++else ++ echo "$as_me: failed program was:" >&5 ++cat conftest.$ac_ext >&5 ++ac_header_compiler=no ++fi ++rm -f conftest.$ac_objext conftest.$ac_ext ++echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 ++echo "${ECHO_T}$ac_header_compiler" >&6 ++ ++# Is the header present? ++echo "$as_me:$LINENO: checking $ac_header presence" >&5 ++echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6 ++cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++#include "confdefs.h" ++@%:@include <$ac_header> ++_ACEOF ++if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 ++ (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 ++ ac_status=$? ++ grep -v '^ *+' conftest.er1 >conftest.err ++ rm -f conftest.er1 ++ cat conftest.err >&5 ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } >/dev/null; then ++ if test -s conftest.err; then ++ ac_cpp_err=$ac_c_preproc_warn_flag ++ else ++ ac_cpp_err= ++ fi ++else ++ ac_cpp_err=yes ++fi ++if test -z "$ac_cpp_err"; then ++ ac_header_preproc=yes ++else ++ echo "$as_me: failed program was:" >&5 ++ cat conftest.$ac_ext >&5 ++ ac_header_preproc=no ++fi ++rm -f conftest.err conftest.$ac_ext ++echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 ++echo "${ECHO_T}$ac_header_preproc" >&6 ++ ++# So? What about this header? ++case $ac_header_compiler:$ac_header_preproc in ++ yes:no ) ++ { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5 ++echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;} ++ { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5 ++echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};; ++ no:yes ) ++ { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5 ++echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;} ++ { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5 ++echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;} ++ { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5 ++echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};; ++esac ++echo "$as_me:$LINENO: checking for $ac_header" >&5 ++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6 ++if eval "test \"\${$as_ac_Header+set}\" = set"; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ eval "$as_ac_Header=$ac_header_preproc" ++fi ++echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5 ++echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6 ++ ++fi ++if test `eval echo '${'$as_ac_Header'}'` = yes; then ++ cat >>confdefs.h <<_ACEOF ++@%:@define `echo "HAVE_$ac_header" | $as_tr_cpp` 1 ++_ACEOF ++ ++fi ++ ++done ++ ++ ++ ++ ++ ++# Only perform the check for file, if the check method requires it ++case $deplibs_check_method in ++file_magic*) ++ if test "$file_magic_cmd" = '$MAGIC_CMD'; then ++ echo "$as_me:$LINENO: checking for ${ac_tool_prefix}file" >&5 ++echo $ECHO_N "checking for ${ac_tool_prefix}file... $ECHO_C" >&6 ++if test "${lt_cv_path_MAGIC_CMD+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ case $MAGIC_CMD in ++ /*) ++ lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path. ++ ;; ++ ?:/*) ++ lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path. ++ ;; ++ *) ++ ac_save_MAGIC_CMD="$MAGIC_CMD" ++ IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS=":" ++ ac_dummy="/usr/bin:$PATH" ++ for ac_dir in $ac_dummy; do ++ test -z "$ac_dir" && ac_dir=. ++ if test -f $ac_dir/${ac_tool_prefix}file; then ++ lt_cv_path_MAGIC_CMD="$ac_dir/${ac_tool_prefix}file" ++ if test -n "$file_magic_test_file"; then ++ case $deplibs_check_method in ++ "file_magic "*) ++ file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`" ++ MAGIC_CMD="$lt_cv_path_MAGIC_CMD" ++ if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null | ++ egrep "$file_magic_regex" > /dev/null; then ++ : ++ else ++ cat <&2 ++ ++*** Warning: the command libtool uses to detect shared libraries, ++*** $file_magic_cmd, produces output that libtool cannot recognize. ++*** The result is that libtool may fail to recognize shared libraries ++*** as such. This will affect the creation of libtool libraries that ++*** depend on shared libraries, but programs linked with such libtool ++*** libraries will work regardless of this problem. Nevertheless, you ++*** may want to report the problem to your system manager and/or to ++*** bug-libtool@gnu.org ++ ++EOF ++ fi ;; ++ esac ++ fi ++ break ++ fi ++ done ++ IFS="$ac_save_ifs" ++ MAGIC_CMD="$ac_save_MAGIC_CMD" ++ ;; ++esac ++fi ++ ++MAGIC_CMD="$lt_cv_path_MAGIC_CMD" ++if test -n "$MAGIC_CMD"; then ++ echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5 ++echo "${ECHO_T}$MAGIC_CMD" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++if test -z "$lt_cv_path_MAGIC_CMD"; then ++ if test -n "$ac_tool_prefix"; then ++ echo "$as_me:$LINENO: checking for file" >&5 ++echo $ECHO_N "checking for file... $ECHO_C" >&6 ++if test "${lt_cv_path_MAGIC_CMD+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ case $MAGIC_CMD in ++ /*) ++ lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path. ++ ;; ++ ?:/*) ++ lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path. ++ ;; ++ *) ++ ac_save_MAGIC_CMD="$MAGIC_CMD" ++ IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS=":" ++ ac_dummy="/usr/bin:$PATH" ++ for ac_dir in $ac_dummy; do ++ test -z "$ac_dir" && ac_dir=. ++ if test -f $ac_dir/file; then ++ lt_cv_path_MAGIC_CMD="$ac_dir/file" ++ if test -n "$file_magic_test_file"; then ++ case $deplibs_check_method in ++ "file_magic "*) ++ file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`" ++ MAGIC_CMD="$lt_cv_path_MAGIC_CMD" ++ if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null | ++ egrep "$file_magic_regex" > /dev/null; then ++ : ++ else ++ cat <&2 ++ ++*** Warning: the command libtool uses to detect shared libraries, ++*** $file_magic_cmd, produces output that libtool cannot recognize. ++*** The result is that libtool may fail to recognize shared libraries ++*** as such. This will affect the creation of libtool libraries that ++*** depend on shared libraries, but programs linked with such libtool ++*** libraries will work regardless of this problem. Nevertheless, you ++*** may want to report the problem to your system manager and/or to ++*** bug-libtool@gnu.org ++ ++EOF ++ fi ;; ++ esac ++ fi ++ break ++ fi ++ done ++ IFS="$ac_save_ifs" ++ MAGIC_CMD="$ac_save_MAGIC_CMD" ++ ;; ++esac ++fi ++ ++MAGIC_CMD="$lt_cv_path_MAGIC_CMD" ++if test -n "$MAGIC_CMD"; then ++ echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5 ++echo "${ECHO_T}$MAGIC_CMD" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++ else ++ MAGIC_CMD=: ++ fi ++fi ++ ++ fi ++ ;; ++esac ++ ++if test -n "$ac_tool_prefix"; then ++ # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args. ++set dummy ${ac_tool_prefix}ranlib; ac_word=$2 ++echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 ++if test "${ac_cv_prog_RANLIB+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$RANLIB"; then ++ ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test. ++else ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ++ ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++ ++fi ++fi ++RANLIB=$ac_cv_prog_RANLIB ++if test -n "$RANLIB"; then ++ echo "$as_me:$LINENO: result: $RANLIB" >&5 ++echo "${ECHO_T}$RANLIB" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++fi ++if test -z "$ac_cv_prog_RANLIB"; then ++ ac_ct_RANLIB=$RANLIB ++ # Extract the first word of "ranlib", so it can be a program name with args. ++set dummy ranlib; ac_word=$2 ++echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 ++if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$ac_ct_RANLIB"; then ++ ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test. ++else ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ++ ac_cv_prog_ac_ct_RANLIB="ranlib" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++ ++ test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":" ++fi ++fi ++ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB ++if test -n "$ac_ct_RANLIB"; then ++ echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5 ++echo "${ECHO_T}$ac_ct_RANLIB" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++ RANLIB=$ac_ct_RANLIB ++else ++ RANLIB="$ac_cv_prog_RANLIB" ++fi ++ ++if test -n "$ac_tool_prefix"; then ++ # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args. ++set dummy ${ac_tool_prefix}strip; ac_word=$2 ++echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 ++if test "${ac_cv_prog_STRIP+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$STRIP"; then ++ ac_cv_prog_STRIP="$STRIP" # Let the user override the test. ++else ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ++ ac_cv_prog_STRIP="${ac_tool_prefix}strip" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++ ++fi ++fi ++STRIP=$ac_cv_prog_STRIP ++if test -n "$STRIP"; then ++ echo "$as_me:$LINENO: result: $STRIP" >&5 ++echo "${ECHO_T}$STRIP" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++fi ++if test -z "$ac_cv_prog_STRIP"; then ++ ac_ct_STRIP=$STRIP ++ # Extract the first word of "strip", so it can be a program name with args. ++set dummy strip; ac_word=$2 ++echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 ++if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test -n "$ac_ct_STRIP"; then ++ ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test. ++else ++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ++ ac_cv_prog_ac_ct_STRIP="strip" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++ ++ test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":" ++fi ++fi ++ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP ++if test -n "$ac_ct_STRIP"; then ++ echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5 ++echo "${ECHO_T}$ac_ct_STRIP" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++ STRIP=$ac_ct_STRIP ++else ++ STRIP="$ac_cv_prog_STRIP" ++fi ++ ++ ++enable_dlopen=no ++enable_win32_dll=no ++ ++# Check whether --enable-libtool-lock or --disable-libtool-lock was given. ++if test "${enable_libtool_lock+set}" = set; then ++ enableval="$enable_libtool_lock" ++ ++fi; ++test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes ++ ++# Some flags need to be propagated to the compiler or linker for good ++# libtool support. ++case $host in ++*-*-irix6*) ++ # Find out which ABI we are using. ++ echo '#line __oline__ "configure"' > conftest.$ac_ext ++ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 ++ (eval $ac_compile) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; then ++ case `/usr/bin/file conftest.$ac_objext` in ++ *32-bit*) ++ LD="${LD-ld} -32" ++ ;; ++ *N32*) ++ LD="${LD-ld} -n32" ++ ;; ++ *64-bit*) ++ LD="${LD-ld} -64" ++ ;; ++ esac ++ fi ++ rm -rf conftest* ++ ;; ++ ++*-*-sco3.2v5*) ++ # On SCO OpenServer 5, we need -belf to get full-featured binaries. ++ SAVE_CFLAGS="$CFLAGS" ++ CFLAGS="$CFLAGS -belf" ++ echo "$as_me:$LINENO: checking whether the C compiler needs -belf" >&5 ++echo $ECHO_N "checking whether the C compiler needs -belf... $ECHO_C" >&6 ++if test "${lt_cv_cc_needs_belf+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ ++ ++ ac_ext=c ++ac_cpp='$CPP $CPPFLAGS' ++ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ++ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ++ac_compiler_gnu=$ac_cv_c_compiler_gnu ++ ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++#include "confdefs.h" ++ ++int ++main () ++{ ++ ++ ; ++ return 0; ++} ++_ACEOF ++rm -f conftest.$ac_objext conftest$ac_exeext ++if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 ++ (eval $ac_link) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && ++ { ac_try='test -s conftest$ac_exeext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ lt_cv_cc_needs_belf=yes ++else ++ echo "$as_me: failed program was:" >&5 ++cat conftest.$ac_ext >&5 ++lt_cv_cc_needs_belf=no ++fi ++rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext ++ ac_ext=c ++ac_cpp='$CPP $CPPFLAGS' ++ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ++ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ++ac_compiler_gnu=$ac_cv_c_compiler_gnu ++ ++fi ++echo "$as_me:$LINENO: result: $lt_cv_cc_needs_belf" >&5 ++echo "${ECHO_T}$lt_cv_cc_needs_belf" >&6 ++ if test x"$lt_cv_cc_needs_belf" != x"yes"; then ++ # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf ++ CFLAGS="$SAVE_CFLAGS" ++ fi ++ ;; ++ ++ ++esac ++ ++# Sed substitution that helps us do robust quoting. It backslashifies ++# metacharacters that are still active within double-quoted strings. ++Xsed='sed -e s/^X//' ++sed_quote_subst='s/\([\\"\\`$\\\\]\)/\\\1/g' ++ ++# Same as above, but do not quote variable references. ++double_quote_subst='s/\([\\"\\`\\\\]\)/\\\1/g' ++ ++# Sed substitution to delay expansion of an escaped shell variable in a ++# double_quote_subst'ed string. ++delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g' ++ ++# Constants: ++rm="rm -f" ++ ++# Global variables: ++default_ofile=libtool ++can_build_shared=yes ++ ++# All known linkers require a `.a' archive for static linking (except M$VC, ++# which needs '.lib'). ++libext=a ++ltmain="$ac_aux_dir/ltmain.sh" ++ofile="$default_ofile" ++with_gnu_ld="$lt_cv_prog_gnu_ld" ++need_locks="$enable_libtool_lock" ++ ++old_CC="$CC" ++old_CFLAGS="$CFLAGS" ++ ++# Set sane defaults for various variables ++test -z "$AR" && AR=ar ++test -z "$AR_FLAGS" && AR_FLAGS=cru ++test -z "$AS" && AS=as ++test -z "$CC" && CC=cc ++test -z "$DLLTOOL" && DLLTOOL=dlltool ++test -z "$LD" && LD=ld ++test -z "$LN_S" && LN_S="ln -s" ++test -z "$MAGIC_CMD" && MAGIC_CMD=file ++test -z "$NM" && NM=nm ++test -z "$OBJDUMP" && OBJDUMP=objdump ++test -z "$RANLIB" && RANLIB=: ++test -z "$STRIP" && STRIP=: ++test -z "$ac_objext" && ac_objext=o ++ ++if test x"$host" != x"$build"; then ++ ac_tool_prefix=${host_alias}- ++else ++ ac_tool_prefix= ++fi ++ ++# Transform linux* to *-*-linux-gnu*, to support old configure scripts. ++case $host_os in ++linux-gnu*) ;; ++linux*) host=`echo $host | sed 's/^\(.*-.*-linux\)\(.*\)$/\1-gnu\2/'` ++esac ++ ++case $host_os in ++aix3*) ++ # AIX sometimes has problems with the GCC collect2 program. For some ++ # reason, if we set the COLLECT_NAMES environment variable, the problems ++ # vanish in a puff of smoke. ++ if test "X${COLLECT_NAMES+set}" != Xset; then ++ COLLECT_NAMES= ++ export COLLECT_NAMES ++ fi ++ ;; ++esac ++ ++# Determine commands to create old-style static archives. ++old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs' ++old_postinstall_cmds='chmod 644 $oldlib' ++old_postuninstall_cmds= ++ ++if test -n "$RANLIB"; then ++ case $host_os in ++ openbsd*) ++ old_postinstall_cmds="\$RANLIB -t \$oldlib~$old_postinstall_cmds" ++ ;; ++ *) ++ old_postinstall_cmds="\$RANLIB \$oldlib~$old_postinstall_cmds" ++ ;; ++ esac ++ old_archive_cmds="$old_archive_cmds~\$RANLIB \$oldlib" ++fi ++ ++# Allow CC to be a program name with arguments. ++set dummy $CC ++compiler="$2" ++ ++echo "$as_me:$LINENO: checking for objdir" >&5 ++echo $ECHO_N "checking for objdir... $ECHO_C" >&6 ++rm -f .libs 2>/dev/null ++mkdir .libs 2>/dev/null ++if test -d .libs; then ++ objdir=.libs ++else ++ # MS-DOS does not allow filenames that begin with a dot. ++ objdir=_libs ++fi ++rmdir .libs 2>/dev/null ++echo "$as_me:$LINENO: result: $objdir" >&5 ++echo "${ECHO_T}$objdir" >&6 ++ ++ ++ ++# Check whether --with-pic or --without-pic was given. ++if test "${with_pic+set}" = set; then ++ withval="$with_pic" ++ pic_mode="$withval" ++else ++ pic_mode=default ++fi; ++test -z "$pic_mode" && pic_mode=default ++ ++# We assume here that the value for lt_cv_prog_cc_pic will not be cached ++# in isolation, and that seeing it set (from the cache) indicates that ++# the associated values are set (in the cache) correctly too. ++echo "$as_me:$LINENO: checking for $compiler option to produce PIC" >&5 ++echo $ECHO_N "checking for $compiler option to produce PIC... $ECHO_C" >&6 ++if test "${lt_cv_prog_cc_pic+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ lt_cv_prog_cc_pic= ++ lt_cv_prog_cc_shlib= ++ lt_cv_prog_cc_wl= ++ lt_cv_prog_cc_static= ++ lt_cv_prog_cc_no_builtin= ++ lt_cv_prog_cc_can_build_shared=$can_build_shared ++ ++ if test "$GCC" = yes; then ++ lt_cv_prog_cc_wl='-Wl,' ++ lt_cv_prog_cc_static='-static' ++ ++ case $host_os in ++ aix*) ++ # Below there is a dirty hack to force normal static linking with -ldl ++ # The problem is because libdl dynamically linked with both libc and ++ # libC (AIX C++ library), which obviously doesn't included in libraries ++ # list by gcc. This cause undefined symbols with -static flags. ++ # This hack allows C programs to be linked with "-static -ldl", but ++ # not sure about C++ programs. ++ lt_cv_prog_cc_static="$lt_cv_prog_cc_static ${lt_cv_prog_cc_wl}-lC" ++ ;; ++ amigaos*) ++ # FIXME: we need at least 68020 code to build shared libraries, but ++ # adding the `-m68020' flag to GCC prevents building anything better, ++ # like `-m68040'. ++ lt_cv_prog_cc_pic='-m68020 -resident32 -malways-restore-a4' ++ ;; ++ beos* | irix5* | irix6* | osf3* | osf4* | osf5*) ++ # PIC is the default for these OSes. ++ ;; ++ darwin* | rhapsody*) ++ # PIC is the default on this platform ++ # Common symbols not allowed in MH_DYLIB files ++ lt_cv_prog_cc_pic='-fno-common' ++ ;; ++ cygwin* | mingw* | pw32* | os2*) ++ # This hack is so that the source file can tell whether it is being ++ # built for inclusion in a dll (and should export symbols for example). ++ lt_cv_prog_cc_pic='-DDLL_EXPORT' ++ ;; ++ sysv4*MP*) ++ if test -d /usr/nec; then ++ lt_cv_prog_cc_pic=-Kconform_pic ++ fi ++ ;; ++ *) ++ lt_cv_prog_cc_pic='-fPIC' ++ ;; ++ esac ++ else ++ # PORTME Check for PIC flags for the system compiler. ++ case $host_os in ++ aix3* | aix4* | aix5*) ++ lt_cv_prog_cc_wl='-Wl,' ++ # All AIX code is PIC. ++ if test "$host_cpu" = ia64; then ++ # AIX 5 now supports IA64 processor ++ lt_cv_prog_cc_static='-Bstatic' ++ else ++ lt_cv_prog_cc_static='-bnso -bI:/lib/syscalls.exp' ++ fi ++ ;; ++ ++ hpux9* | hpux10* | hpux11*) ++ # Is there a better lt_cv_prog_cc_static that works with the bundled CC? ++ lt_cv_prog_cc_wl='-Wl,' ++ lt_cv_prog_cc_static="${lt_cv_prog_cc_wl}-a ${lt_cv_prog_cc_wl}archive" ++ lt_cv_prog_cc_pic='+Z' ++ ;; ++ ++ irix5* | irix6*) ++ lt_cv_prog_cc_wl='-Wl,' ++ lt_cv_prog_cc_static='-non_shared' ++ # PIC (with -KPIC) is the default. ++ ;; ++ ++ cygwin* | mingw* | pw32* | os2*) ++ # This hack is so that the source file can tell whether it is being ++ # built for inclusion in a dll (and should export symbols for example). ++ lt_cv_prog_cc_pic='-DDLL_EXPORT' ++ ;; ++ ++ newsos6) ++ lt_cv_prog_cc_pic='-KPIC' ++ lt_cv_prog_cc_static='-Bstatic' ++ ;; ++ ++ osf3* | osf4* | osf5*) ++ # All OSF/1 code is PIC. ++ lt_cv_prog_cc_wl='-Wl,' ++ lt_cv_prog_cc_static='-non_shared' ++ ;; ++ ++ sco3.2v5*) ++ lt_cv_prog_cc_pic='-Kpic' ++ lt_cv_prog_cc_static='-dn' ++ lt_cv_prog_cc_shlib='-belf' ++ ;; ++ ++ solaris*) ++ lt_cv_prog_cc_pic='-KPIC' ++ lt_cv_prog_cc_static='-Bstatic' ++ lt_cv_prog_cc_wl='-Wl,' ++ ;; ++ ++ sunos4*) ++ lt_cv_prog_cc_pic='-PIC' ++ lt_cv_prog_cc_static='-Bstatic' ++ lt_cv_prog_cc_wl='-Qoption ld ' ++ ;; ++ ++ sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) ++ lt_cv_prog_cc_pic='-KPIC' ++ lt_cv_prog_cc_static='-Bstatic' ++ if test "x$host_vendor" = xsni; then ++ lt_cv_prog_cc_wl='-LD' ++ else ++ lt_cv_prog_cc_wl='-Wl,' ++ fi ++ ;; ++ ++ uts4*) ++ lt_cv_prog_cc_pic='-pic' ++ lt_cv_prog_cc_static='-Bstatic' ++ ;; ++ ++ sysv4*MP*) ++ if test -d /usr/nec ;then ++ lt_cv_prog_cc_pic='-Kconform_pic' ++ lt_cv_prog_cc_static='-Bstatic' ++ fi ++ ;; ++ ++ *) ++ lt_cv_prog_cc_can_build_shared=no ++ ;; ++ esac ++ fi ++ ++fi ++ ++if test -z "$lt_cv_prog_cc_pic"; then ++ echo "$as_me:$LINENO: result: none" >&5 ++echo "${ECHO_T}none" >&6 ++else ++ echo "$as_me:$LINENO: result: $lt_cv_prog_cc_pic" >&5 ++echo "${ECHO_T}$lt_cv_prog_cc_pic" >&6 ++ ++ # Check to make sure the pic_flag actually works. ++ echo "$as_me:$LINENO: checking if $compiler PIC flag $lt_cv_prog_cc_pic works" >&5 ++echo $ECHO_N "checking if $compiler PIC flag $lt_cv_prog_cc_pic works... $ECHO_C" >&6 ++ if test "${lt_cv_prog_cc_pic_works+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ save_CFLAGS="$CFLAGS" ++ CFLAGS="$CFLAGS $lt_cv_prog_cc_pic -DPIC" ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++#include "confdefs.h" ++ ++int ++main () ++{ ++ ++ ; ++ return 0; ++} ++_ACEOF ++rm -f conftest.$ac_objext ++if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 ++ (eval $ac_compile) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && ++ { ac_try='test -s conftest.$ac_objext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ case $host_os in ++ hpux9* | hpux10* | hpux11*) ++ # On HP-UX, both CC and GCC only warn that PIC is supported... then ++ # they create non-PIC objects. So, if there were any warnings, we ++ # assume that PIC is not supported. ++ if test -s conftest.err; then ++ lt_cv_prog_cc_pic_works=no ++ else ++ lt_cv_prog_cc_pic_works=yes ++ fi ++ ;; ++ *) ++ lt_cv_prog_cc_pic_works=yes ++ ;; ++ esac ++ ++else ++ echo "$as_me: failed program was:" >&5 ++cat conftest.$ac_ext >&5 ++ lt_cv_prog_cc_pic_works=no ++ ++fi ++rm -f conftest.$ac_objext conftest.$ac_ext ++ CFLAGS="$save_CFLAGS" ++ ++fi ++ ++ ++ if test "X$lt_cv_prog_cc_pic_works" = Xno; then ++ lt_cv_prog_cc_pic= ++ lt_cv_prog_cc_can_build_shared=no ++ else ++ lt_cv_prog_cc_pic=" $lt_cv_prog_cc_pic" ++ fi ++ ++ echo "$as_me:$LINENO: result: $lt_cv_prog_cc_pic_works" >&5 ++echo "${ECHO_T}$lt_cv_prog_cc_pic_works" >&6 ++fi ++ ++# Check for any special shared library compilation flags. ++if test -n "$lt_cv_prog_cc_shlib"; then ++ { echo "$as_me:$LINENO: WARNING: \`$CC' requires \`$lt_cv_prog_cc_shlib' to build shared libraries" >&5 ++echo "$as_me: WARNING: \`$CC' requires \`$lt_cv_prog_cc_shlib' to build shared libraries" >&2;} ++ if echo "$old_CC $old_CFLAGS " | egrep -e "[ ]$lt_cv_prog_cc_shlib[ ]" >/dev/null; then : ++ else ++ { echo "$as_me:$LINENO: WARNING: add \`$lt_cv_prog_cc_shlib' to the CC or CFLAGS env variable and reconfigure" >&5 ++echo "$as_me: WARNING: add \`$lt_cv_prog_cc_shlib' to the CC or CFLAGS env variable and reconfigure" >&2;} ++ lt_cv_prog_cc_can_build_shared=no ++ fi ++fi ++ ++echo "$as_me:$LINENO: checking if $compiler static flag $lt_cv_prog_cc_static works" >&5 ++echo $ECHO_N "checking if $compiler static flag $lt_cv_prog_cc_static works... $ECHO_C" >&6 ++if test "${lt_cv_prog_cc_static_works+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ lt_cv_prog_cc_static_works=no ++ save_LDFLAGS="$LDFLAGS" ++ LDFLAGS="$LDFLAGS $lt_cv_prog_cc_static" ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++#include "confdefs.h" ++ ++int ++main () ++{ ++ ++ ; ++ return 0; ++} ++_ACEOF ++rm -f conftest.$ac_objext conftest$ac_exeext ++if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 ++ (eval $ac_link) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && ++ { ac_try='test -s conftest$ac_exeext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ lt_cv_prog_cc_static_works=yes ++else ++ echo "$as_me: failed program was:" >&5 ++cat conftest.$ac_ext >&5 ++fi ++rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext ++ LDFLAGS="$save_LDFLAGS" ++ ++fi ++ ++ ++# Belt *and* braces to stop my trousers falling down: ++test "X$lt_cv_prog_cc_static_works" = Xno && lt_cv_prog_cc_static= ++echo "$as_me:$LINENO: result: $lt_cv_prog_cc_static_works" >&5 ++echo "${ECHO_T}$lt_cv_prog_cc_static_works" >&6 ++ ++pic_flag="$lt_cv_prog_cc_pic" ++special_shlib_compile_flags="$lt_cv_prog_cc_shlib" ++wl="$lt_cv_prog_cc_wl" ++link_static_flag="$lt_cv_prog_cc_static" ++no_builtin_flag="$lt_cv_prog_cc_no_builtin" ++can_build_shared="$lt_cv_prog_cc_can_build_shared" ++ ++ ++# Check to see if options -o and -c are simultaneously supported by compiler ++echo "$as_me:$LINENO: checking if $compiler supports -c -o file.$ac_objext" >&5 ++echo $ECHO_N "checking if $compiler supports -c -o file.$ac_objext... $ECHO_C" >&6 ++if test "${lt_cv_compiler_c_o+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ ++$rm -r conftest 2>/dev/null ++mkdir conftest ++cd conftest ++echo "int some_variable = 0;" > conftest.$ac_ext ++mkdir out ++# According to Tom Tromey, Ian Lance Taylor reported there are C compilers ++# that will create temporary files in the current directory regardless of ++# the output directory. Thus, making CWD read-only will cause this test ++# to fail, enabling locking or at least warning the user not to do parallel ++# builds. ++chmod -w . ++save_CFLAGS="$CFLAGS" ++CFLAGS="$CFLAGS -o out/conftest2.$ac_objext" ++compiler_c_o=no ++if { (eval echo configure:__oline__: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>out/conftest.err; } && test -s out/conftest2.$ac_objext; then ++ # The compiler can only warn and ignore the option if not recognized ++ # So say no if there are warnings ++ if test -s out/conftest.err; then ++ lt_cv_compiler_c_o=no ++ else ++ lt_cv_compiler_c_o=yes ++ fi ++else ++ # Append any errors to the config.log. ++ cat out/conftest.err 1>&5 ++ lt_cv_compiler_c_o=no ++fi ++CFLAGS="$save_CFLAGS" ++chmod u+w . ++$rm conftest* out/* ++rmdir out ++cd .. ++rmdir conftest ++$rm -r conftest 2>/dev/null ++ ++fi ++ ++compiler_c_o=$lt_cv_compiler_c_o ++echo "$as_me:$LINENO: result: $compiler_c_o" >&5 ++echo "${ECHO_T}$compiler_c_o" >&6 ++ ++if test x"$compiler_c_o" = x"yes"; then ++ # Check to see if we can write to a .lo ++ echo "$as_me:$LINENO: checking if $compiler supports -c -o file.lo" >&5 ++echo $ECHO_N "checking if $compiler supports -c -o file.lo... $ECHO_C" >&6 ++ if test "${lt_cv_compiler_o_lo+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ ++ lt_cv_compiler_o_lo=no ++ save_CFLAGS="$CFLAGS" ++ CFLAGS="$CFLAGS -c -o conftest.lo" ++ save_objext="$ac_objext" ++ ac_objext=lo ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++#include "confdefs.h" ++ ++int ++main () ++{ ++int some_variable = 0; ++ ; ++ return 0; ++} ++_ACEOF ++rm -f conftest.$ac_objext ++if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 ++ (eval $ac_compile) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && ++ { ac_try='test -s conftest.$ac_objext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ # The compiler can only warn and ignore the option if not recognized ++ # So say no if there are warnings ++ if test -s conftest.err; then ++ lt_cv_compiler_o_lo=no ++ else ++ lt_cv_compiler_o_lo=yes ++ fi ++ ++else ++ echo "$as_me: failed program was:" >&5 ++cat conftest.$ac_ext >&5 ++fi ++rm -f conftest.$ac_objext conftest.$ac_ext ++ ac_objext="$save_objext" ++ CFLAGS="$save_CFLAGS" ++ ++fi ++ ++ compiler_o_lo=$lt_cv_compiler_o_lo ++ echo "$as_me:$LINENO: result: $compiler_o_lo" >&5 ++echo "${ECHO_T}$compiler_o_lo" >&6 ++else ++ compiler_o_lo=no ++fi ++ ++# Check to see if we can do hard links to lock some files if needed ++hard_links="nottested" ++if test "$compiler_c_o" = no && test "$need_locks" != no; then ++ # do not overwrite the value of need_locks provided by the user ++ echo "$as_me:$LINENO: checking if we can lock with hard links" >&5 ++echo $ECHO_N "checking if we can lock with hard links... $ECHO_C" >&6 ++ hard_links=yes ++ $rm conftest* ++ ln conftest.a conftest.b 2>/dev/null && hard_links=no ++ touch conftest.a ++ ln conftest.a conftest.b 2>&5 || hard_links=no ++ ln conftest.a conftest.b 2>/dev/null && hard_links=no ++ echo "$as_me:$LINENO: result: $hard_links" >&5 ++echo "${ECHO_T}$hard_links" >&6 ++ if test "$hard_links" = no; then ++ { echo "$as_me:$LINENO: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5 ++echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;} ++ need_locks=warn ++ fi ++else ++ need_locks=no ++fi ++ ++if test "$GCC" = yes; then ++ # Check to see if options -fno-rtti -fno-exceptions are supported by compiler ++ echo "$as_me:$LINENO: checking if $compiler supports -fno-rtti -fno-exceptions" >&5 ++echo $ECHO_N "checking if $compiler supports -fno-rtti -fno-exceptions... $ECHO_C" >&6 ++ echo "int some_variable = 0;" > conftest.$ac_ext ++ save_CFLAGS="$CFLAGS" ++ CFLAGS="$CFLAGS -fno-rtti -fno-exceptions -c conftest.$ac_ext" ++ compiler_rtti_exceptions=no ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++#include "confdefs.h" ++ ++int ++main () ++{ ++int some_variable = 0; ++ ; ++ return 0; ++} ++_ACEOF ++rm -f conftest.$ac_objext ++if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 ++ (eval $ac_compile) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && ++ { ac_try='test -s conftest.$ac_objext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ # The compiler can only warn and ignore the option if not recognized ++ # So say no if there are warnings ++ if test -s conftest.err; then ++ compiler_rtti_exceptions=no ++ else ++ compiler_rtti_exceptions=yes ++ fi ++ ++else ++ echo "$as_me: failed program was:" >&5 ++cat conftest.$ac_ext >&5 ++fi ++rm -f conftest.$ac_objext conftest.$ac_ext ++ CFLAGS="$save_CFLAGS" ++ echo "$as_me:$LINENO: result: $compiler_rtti_exceptions" >&5 ++echo "${ECHO_T}$compiler_rtti_exceptions" >&6 ++ ++ if test "$compiler_rtti_exceptions" = "yes"; then ++ no_builtin_flag=' -fno-builtin -fno-rtti -fno-exceptions' ++ else ++ no_builtin_flag=' -fno-builtin' ++ fi ++fi ++ ++# See if the linker supports building shared libraries. ++echo "$as_me:$LINENO: checking whether the linker ($LD) supports shared libraries" >&5 ++echo $ECHO_N "checking whether the linker ($LD) supports shared libraries... $ECHO_C" >&6 ++ ++allow_undefined_flag= ++no_undefined_flag= ++need_lib_prefix=unknown ++need_version=unknown ++# when you set need_version to no, make sure it does not cause -set_version ++# flags to be left without arguments ++archive_cmds= ++archive_expsym_cmds= ++old_archive_from_new_cmds= ++old_archive_from_expsyms_cmds= ++export_dynamic_flag_spec= ++whole_archive_flag_spec= ++thread_safe_flag_spec= ++hardcode_into_libs=no ++hardcode_libdir_flag_spec= ++hardcode_libdir_separator= ++hardcode_direct=no ++hardcode_minus_L=no ++hardcode_shlibpath_var=unsupported ++runpath_var= ++link_all_deplibs=unknown ++always_export_symbols=no ++export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | sed '\''s/.* //'\'' | sort | uniq > $export_symbols' ++# include_expsyms should be a list of space-separated symbols to be *always* ++# included in the symbol list ++include_expsyms= ++# exclude_expsyms can be an egrep regular expression of symbols to exclude ++# it will be wrapped by ` (' and `)$', so one must not match beginning or ++# end of line. Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc', ++# as well as any symbol that contains `d'. ++exclude_expsyms="_GLOBAL_OFFSET_TABLE_" ++# Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out ++# platforms (ab)use it in PIC code, but their linkers get confused if ++# the symbol is explicitly referenced. Since portable code cannot ++# rely on this symbol name, it's probably fine to never include it in ++# preloaded symbol tables. ++extract_expsyms_cmds= ++ ++case $host_os in ++cygwin* | mingw* | pw32*) ++ # FIXME: the MSVC++ port hasn't been tested in a loooong time ++ # When not using gcc, we currently assume that we are using ++ # Microsoft Visual C++. ++ if test "$GCC" != yes; then ++ with_gnu_ld=no ++ fi ++ ;; ++openbsd*) ++ with_gnu_ld=no ++ ;; ++esac ++ ++ld_shlibs=yes ++if test "$with_gnu_ld" = yes; then ++ # If archive_cmds runs LD, not CC, wlarc should be empty ++ wlarc='${wl}' ++ ++ # See if GNU ld supports shared libraries. ++ case $host_os in ++ aix3* | aix4* | aix5*) ++ # On AIX, the GNU linker is very broken ++ # Note:Check GNU linker on AIX 5-IA64 when/if it becomes available. ++ ld_shlibs=no ++ cat <&2 ++ ++*** Warning: the GNU linker, at least up to release 2.9.1, is reported ++*** to be unable to reliably create shared libraries on AIX. ++*** Therefore, libtool is disabling shared libraries support. If you ++*** really care for shared libraries, you may want to modify your PATH ++*** so that a non-GNU linker is found, and then restart. ++ ++EOF ++ ;; ++ ++ amigaos*) ++ archive_cmds='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' ++ hardcode_libdir_flag_spec='-L$libdir' ++ hardcode_minus_L=yes ++ ++ # Samuel A. Falvo II reports ++ # that the semantics of dynamic libraries on AmigaOS, at least up ++ # to version 4, is to share data among multiple programs linked ++ # with the same dynamic library. Since this doesn't match the ++ # behavior of shared libraries on other platforms, we can use ++ # them. ++ ld_shlibs=no ++ ;; ++ ++ beos*) ++ if $LD --help 2>&1 | egrep ': supported targets:.* elf' > /dev/null; then ++ allow_undefined_flag=unsupported ++ # Joseph Beckenbach says some releases of gcc ++ # support --undefined. This deserves some investigation. FIXME ++ archive_cmds='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' ++ else ++ ld_shlibs=no ++ fi ++ ;; ++ ++ cygwin* | mingw* | pw32*) ++ # hardcode_libdir_flag_spec is actually meaningless, as there is ++ # no search path for DLLs. ++ hardcode_libdir_flag_spec='-L$libdir' ++ allow_undefined_flag=unsupported ++ always_export_symbols=yes ++ ++ extract_expsyms_cmds='test -f $output_objdir/impgen.c || \ ++ sed -e "/^# \/\* impgen\.c starts here \*\//,/^# \/\* impgen.c ends here \*\// { s/^# //;s/^# *$//; p; }" -e d < $''0 > $output_objdir/impgen.c~ ++ test -f $output_objdir/impgen.exe || (cd $output_objdir && \ ++ if test "x$HOST_CC" != "x" ; then $HOST_CC -o impgen impgen.c ; \ ++ else $CC -o impgen impgen.c ; fi)~ ++ $output_objdir/impgen $dir/$soroot > $output_objdir/$soname-def' ++ ++ old_archive_from_expsyms_cmds='$DLLTOOL --as=$AS --dllname $soname --def $output_objdir/$soname-def --output-lib $output_objdir/$newlib' ++ ++ # cygwin and mingw dlls have different entry points and sets of symbols ++ # to exclude. ++ # FIXME: what about values for MSVC? ++ dll_entry=__cygwin_dll_entry@12 ++ dll_exclude_symbols=DllMain@12,_cygwin_dll_entry@12,_cygwin_noncygwin_dll_entry@12~ ++ case $host_os in ++ mingw*) ++ # mingw values ++ dll_entry=_DllMainCRTStartup@12 ++ dll_exclude_symbols=DllMain@12,DllMainCRTStartup@12,DllEntryPoint@12~ ++ ;; ++ esac ++ ++ # mingw and cygwin differ, and it's simplest to just exclude the union ++ # of the two symbol sets. ++ dll_exclude_symbols=DllMain@12,_cygwin_dll_entry@12,_cygwin_noncygwin_dll_entry@12,DllMainCRTStartup@12,DllEntryPoint@12 ++ ++ # recent cygwin and mingw systems supply a stub DllMain which the user ++ # can override, but on older systems we have to supply one (in ltdll.c) ++ if test "x$lt_cv_need_dllmain" = "xyes"; then ++ ltdll_obj='$output_objdir/$soname-ltdll.'"$ac_objext " ++ ltdll_cmds='test -f $output_objdir/$soname-ltdll.c || sed -e "/^# \/\* ltdll\.c starts here \*\//,/^# \/\* ltdll.c ends here \*\// { s/^# //; p; }" -e d < $''0 > $output_objdir/$soname-ltdll.c~ ++ test -f $output_objdir/$soname-ltdll.$ac_objext || (cd $output_objdir && $CC -c $soname-ltdll.c)~' ++ else ++ ltdll_obj= ++ ltdll_cmds= ++ fi ++ ++ # Extract the symbol export list from an `--export-all' def file, ++ # then regenerate the def file from the symbol export list, so that ++ # the compiled dll only exports the symbol export list. ++ # Be careful not to strip the DATA tag left be newer dlltools. ++ export_symbols_cmds="$ltdll_cmds"' ++ $DLLTOOL --export-all --exclude-symbols '$dll_exclude_symbols' --output-def $output_objdir/$soname-def '$ltdll_obj'$libobjs $convenience~ ++ sed -e "1,/EXPORTS/d" -e "s/ @ [0-9]*//" -e "s/ *;.*$//" < $output_objdir/$soname-def > $export_symbols' ++ ++ # If the export-symbols file already is a .def file (1st line ++ # is EXPORTS), use it as is. ++ # If DATA tags from a recent dlltool are present, honour them! ++ archive_expsym_cmds='if test "x`head -1 $export_symbols`" = xEXPORTS; then ++ cp $export_symbols $output_objdir/$soname-def; ++ else ++ echo EXPORTS > $output_objdir/$soname-def; ++ _lt_hint=1; ++ cat $export_symbols | while read symbol; do ++ set dummy \$symbol; ++ case \$# in ++ 2) echo " \$2 @ \$_lt_hint ; " >> $output_objdir/$soname-def;; ++ *) echo " \$2 @ \$_lt_hint \$3 ; " >> $output_objdir/$soname-def;; ++ esac; ++ _lt_hint=`expr 1 + \$_lt_hint`; ++ done; ++ fi~ ++ '"$ltdll_cmds"' ++ $CC -Wl,--base-file,$output_objdir/$soname-base '$lt_cv_cc_dll_switch' -Wl,-e,'$dll_entry' -o $output_objdir/$soname '$ltdll_obj'$libobjs $deplibs $compiler_flags~ ++ $DLLTOOL --as=$AS --dllname $soname --exclude-symbols '$dll_exclude_symbols' --def $output_objdir/$soname-def --base-file $output_objdir/$soname-base --output-exp $output_objdir/$soname-exp~ ++ $CC -Wl,--base-file,$output_objdir/$soname-base $output_objdir/$soname-exp '$lt_cv_cc_dll_switch' -Wl,-e,'$dll_entry' -o $output_objdir/$soname '$ltdll_obj'$libobjs $deplibs $compiler_flags~ ++ $DLLTOOL --as=$AS --dllname $soname --exclude-symbols '$dll_exclude_symbols' --def $output_objdir/$soname-def --base-file $output_objdir/$soname-base --output-exp $output_objdir/$soname-exp --output-lib $output_objdir/$libname.dll.a~ ++ $CC $output_objdir/$soname-exp '$lt_cv_cc_dll_switch' -Wl,-e,'$dll_entry' -o $output_objdir/$soname '$ltdll_obj'$libobjs $deplibs $compiler_flags' ++ ;; ++ ++ netbsd*) ++ if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then ++ archive_cmds='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib' ++ wlarc= ++ else ++ archive_cmds='$CC -shared -nodefaultlibs $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' ++ archive_expsym_cmds='$CC -shared -nodefaultlibs $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' ++ fi ++ ;; ++ ++ solaris* | sysv5*) ++ if $LD -v 2>&1 | egrep 'BFD 2\.8' > /dev/null; then ++ ld_shlibs=no ++ cat <&2 ++ ++*** Warning: The releases 2.8.* of the GNU linker cannot reliably ++*** create shared libraries on Solaris systems. Therefore, libtool ++*** is disabling shared libraries support. We urge you to upgrade GNU ++*** binutils to release 2.9.1 or newer. Another option is to modify ++*** your PATH or compiler configuration so that the native linker is ++*** used, and then restart. ++ ++EOF ++ elif $LD --help 2>&1 | egrep ': supported targets:.* elf' > /dev/null; then ++ archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' ++ archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' ++ else ++ ld_shlibs=no ++ fi ++ ;; ++ ++ sunos4*) ++ archive_cmds='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags' ++ wlarc= ++ hardcode_direct=yes ++ hardcode_shlibpath_var=no ++ ;; ++ ++ *) ++ if $LD --help 2>&1 | egrep ': supported targets:.* elf' > /dev/null; then ++ archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' ++ archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' ++ else ++ ld_shlibs=no ++ fi ++ ;; ++ esac ++ ++ if test "$ld_shlibs" = yes; then ++ runpath_var=LD_RUN_PATH ++ hardcode_libdir_flag_spec='${wl}--rpath ${wl}$libdir' ++ export_dynamic_flag_spec='${wl}--export-dynamic' ++ case $host_os in ++ cygwin* | mingw* | pw32*) ++ # dlltool doesn't understand --whole-archive et. al. ++ whole_archive_flag_spec= ++ ;; ++ *) ++ # ancient GNU ld didn't support --whole-archive et. al. ++ if $LD --help 2>&1 | egrep 'no-whole-archive' > /dev/null; then ++ whole_archive_flag_spec="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' ++ else ++ whole_archive_flag_spec= ++ fi ++ ;; ++ esac ++ fi ++else ++ # PORTME fill in a description of your system's linker (not GNU ld) ++ case $host_os in ++ aix3*) ++ allow_undefined_flag=unsupported ++ always_export_symbols=yes ++ archive_expsym_cmds='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname' ++ # Note: this linker hardcodes the directories in LIBPATH if there ++ # are no directories specified by -L. ++ hardcode_minus_L=yes ++ if test "$GCC" = yes && test -z "$link_static_flag"; then ++ # Neither direct hardcoding nor static linking is supported with a ++ # broken collect2. ++ hardcode_direct=unsupported ++ fi ++ ;; ++ ++ aix4* | aix5*) ++ if test "$host_cpu" = ia64; then ++ # On IA64, the linker does run time linking by default, so we don't ++ # have to do anything special. ++ aix_use_runtimelinking=no ++ exp_sym_flag='-Bexport' ++ no_entry_flag="" ++ else ++ aix_use_runtimelinking=no ++ ++ # Test if we are trying to use run time linking or normal ++ # AIX style linking. If -brtl is somewhere in LDFLAGS, we ++ # need to do runtime linking. ++ case $host_os in aix4.[23]|aix4.[23].*|aix5*) ++ for ld_flag in $LDFLAGS; do ++ if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then ++ aix_use_runtimelinking=yes ++ break ++ fi ++ done ++ esac ++ ++ exp_sym_flag='-bexport' ++ no_entry_flag='-bnoentry' ++ fi ++ ++ # When large executables or shared objects are built, AIX ld can ++ # have problems creating the table of contents. If linking a library ++ # or program results in "error TOC overflow" add -mminimal-toc to ++ # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not ++ # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS. ++ ++ hardcode_direct=yes ++ archive_cmds='' ++ hardcode_libdir_separator=':' ++ if test "$GCC" = yes; then ++ case $host_os in aix4.[012]|aix4.[012].*) ++ collect2name=`${CC} -print-prog-name=collect2` ++ if test -f "$collect2name" && \ ++ strings "$collect2name" | grep resolve_lib_name >/dev/null ++ then ++ # We have reworked collect2 ++ hardcode_direct=yes ++ else ++ # We have old collect2 ++ hardcode_direct=unsupported ++ # It fails to find uninstalled libraries when the uninstalled ++ # path is not listed in the libpath. Setting hardcode_minus_L ++ # to unsupported forces relinking ++ hardcode_minus_L=yes ++ hardcode_libdir_flag_spec='-L$libdir' ++ hardcode_libdir_separator= ++ fi ++ esac ++ ++ shared_flag='-shared' ++ else ++ # not using gcc ++ if test "$host_cpu" = ia64; then ++ shared_flag='${wl}-G' ++ else ++ if test "$aix_use_runtimelinking" = yes; then ++ shared_flag='${wl}-G' ++ else ++ shared_flag='${wl}-bM:SRE' ++ fi ++ fi ++ fi ++ ++ # It seems that -bexpall can do strange things, so it is better to ++ # generate a list of symbols to export. ++ always_export_symbols=yes ++ if test "$aix_use_runtimelinking" = yes; then ++ # Warning - without using the other runtime loading flags (-brtl), ++ # -berok will link without error, but may produce a broken library. ++ allow_undefined_flag='-berok' ++ hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:/usr/lib:/lib' ++ archive_expsym_cmds="\$CC"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols $shared_flag" ++ else ++ if test "$host_cpu" = ia64; then ++ hardcode_libdir_flag_spec='${wl}-R $libdir:/usr/lib:/lib' ++ allow_undefined_flag="-z nodefs" ++ archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname ${wl}-h$soname $libobjs $deplibs $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols" ++ else ++ hardcode_libdir_flag_spec='${wl}-bnolibpath ${wl}-blibpath:$libdir:/usr/lib:/lib' ++ # Warning - without using the other run time loading flags, ++ # -berok will link without error, but may produce a broken library. ++ allow_undefined_flag='${wl}-berok' ++ # This is a bit strange, but is similar to how AIX traditionally builds ++ # it's shared libraries. ++ archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${allow_undefined_flag} '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols"' ~$AR -crlo $objdir/$libname$release.a $objdir/$soname' ++ fi ++ fi ++ ;; ++ ++ amigaos*) ++ archive_cmds='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' ++ hardcode_libdir_flag_spec='-L$libdir' ++ hardcode_minus_L=yes ++ # see comment about different semantics on the GNU ld section ++ ld_shlibs=no ++ ;; ++ ++ cygwin* | mingw* | pw32*) ++ # When not using gcc, we currently assume that we are using ++ # Microsoft Visual C++. ++ # hardcode_libdir_flag_spec is actually meaningless, as there is ++ # no search path for DLLs. ++ hardcode_libdir_flag_spec=' ' ++ allow_undefined_flag=unsupported ++ # Tell ltmain to make .lib files, not .a files. ++ libext=lib ++ # FIXME: Setting linknames here is a bad hack. ++ archive_cmds='$CC -o $lib $libobjs $compiler_flags `echo "$deplibs" | sed -e '\''s/ -lc$//'\''` -link -dll~linknames=' ++ # The linker will automatically build a .lib file if we build a DLL. ++ old_archive_from_new_cmds='true' ++ # FIXME: Should let the user specify the lib program. ++ old_archive_cmds='lib /OUT:$oldlib$oldobjs$old_deplibs' ++ fix_srcfile_path='`cygpath -w "$srcfile"`' ++ ;; ++ ++ darwin* | rhapsody*) ++ case "$host_os" in ++ rhapsody* | darwin1.[012]) ++ allow_undefined_flag='-undefined suppress' ++ ;; ++ *) # Darwin 1.3 on ++ allow_undefined_flag='-flat_namespace -undefined suppress' ++ ;; ++ esac ++ # FIXME: Relying on posixy $() will cause problems for ++ # cross-compilation, but unfortunately the echo tests do not ++ # yet detect zsh echo's removal of \ escapes. ++ archive_cmds='$nonopt $(test "x$module" = xyes && echo -bundle || echo -dynamiclib) $allow_undefined_flag -o $lib $libobjs $deplibs$linker_flags -install_name $rpath/$soname $verstring' ++ # We need to add '_' to the symbols in $export_symbols first ++ #archive_expsym_cmds="$archive_cmds"' && strip -s $export_symbols' ++ hardcode_direct=yes ++ hardcode_shlibpath_var=no ++ whole_archive_flag_spec='-all_load $convenience' ++ ;; ++ ++ freebsd1*) ++ ld_shlibs=no ++ ;; ++ ++ # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor ++ # support. Future versions do this automatically, but an explicit c++rt0.o ++ # does not break anything, and helps significantly (at the cost of a little ++ # extra space). ++ freebsd2.2*) ++ archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o' ++ hardcode_libdir_flag_spec='-R$libdir' ++ hardcode_direct=yes ++ hardcode_shlibpath_var=no ++ ;; ++ ++ # Unfortunately, older versions of FreeBSD 2 do not have this feature. ++ freebsd2*) ++ archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' ++ hardcode_direct=yes ++ hardcode_minus_L=yes ++ hardcode_shlibpath_var=no ++ ;; ++ ++ # FreeBSD 3 and greater uses gcc -shared to do shared libraries. ++ freebsd*) ++ archive_cmds='$CC -shared -o $lib $libobjs $deplibs $compiler_flags' ++ hardcode_libdir_flag_spec='-R$libdir' ++ hardcode_direct=yes ++ hardcode_shlibpath_var=no ++ ;; ++ ++ hpux9* | hpux10* | hpux11*) ++ case $host_os in ++ hpux9*) archive_cmds='$rm $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' ;; ++ *) archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags' ;; ++ esac ++ hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir' ++ hardcode_libdir_separator=: ++ hardcode_direct=yes ++ hardcode_minus_L=yes # Not in the search PATH, but as the default ++ # location of the library. ++ export_dynamic_flag_spec='${wl}-E' ++ ;; ++ ++ irix5* | irix6*) ++ if test "$GCC" = yes; then ++ archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' ++ else ++ archive_cmds='$LD -shared $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib' ++ fi ++ hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' ++ hardcode_libdir_separator=: ++ link_all_deplibs=yes ++ ;; ++ ++ netbsd*) ++ if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then ++ archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' # a.out ++ else ++ archive_cmds='$LD -shared -o $lib $libobjs $deplibs $linker_flags' # ELF ++ fi ++ hardcode_libdir_flag_spec='-R$libdir' ++ hardcode_direct=yes ++ hardcode_shlibpath_var=no ++ ;; ++ ++ newsos6) ++ archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' ++ hardcode_direct=yes ++ hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' ++ hardcode_libdir_separator=: ++ hardcode_shlibpath_var=no ++ ;; ++ ++ openbsd*) ++ hardcode_direct=yes ++ hardcode_shlibpath_var=no ++ if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then ++ archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $linker_flags' ++ hardcode_libdir_flag_spec='${wl}-rpath,$libdir' ++ export_dynamic_flag_spec='${wl}-E' ++ else ++ case "$host_os" in ++ openbsd[01].* | openbsd2.[0-7] | openbsd2.[0-7].*) ++ archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' ++ hardcode_libdir_flag_spec='-R$libdir' ++ ;; ++ *) ++ archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $linker_flags' ++ hardcode_libdir_flag_spec='${wl}-rpath,$libdir' ++ ;; ++ esac ++ fi ++ ;; ++ ++ os2*) ++ hardcode_libdir_flag_spec='-L$libdir' ++ hardcode_minus_L=yes ++ allow_undefined_flag=unsupported ++ archive_cmds='$echo "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$echo "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~$echo DATA >> $output_objdir/$libname.def~$echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~$echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def' ++ old_archive_from_new_cmds='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def' ++ ;; ++ ++ osf3*) ++ if test "$GCC" = yes; then ++ allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*' ++ archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' ++ else ++ allow_undefined_flag=' -expect_unresolved \*' ++ archive_cmds='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib' ++ fi ++ hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' ++ hardcode_libdir_separator=: ++ ;; ++ ++ osf4* | osf5*) # as osf3* with the addition of -msym flag ++ if test "$GCC" = yes; then ++ allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*' ++ archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' ++ hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' ++ else ++ allow_undefined_flag=' -expect_unresolved \*' ++ archive_cmds='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -msym -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib' ++ archive_expsym_cmds='for i in `cat $export_symbols`; do printf "-exported_symbol " >> $lib.exp; echo "\$i" >> $lib.exp; done; echo "-hidden">> $lib.exp~ ++ $LD -shared${allow_undefined_flag} -input $lib.exp $linker_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${objdir}/so_locations -o $lib~$rm $lib.exp' ++ ++ #Both c and cxx compiler support -rpath directly ++ hardcode_libdir_flag_spec='-rpath $libdir' ++ fi ++ hardcode_libdir_separator=: ++ ;; ++ ++ sco3.2v5*) ++ archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' ++ hardcode_shlibpath_var=no ++ runpath_var=LD_RUN_PATH ++ hardcode_runpath_var=yes ++ export_dynamic_flag_spec='${wl}-Bexport' ++ ;; ++ ++ solaris*) ++ # gcc --version < 3.0 without binutils cannot create self contained ++ # shared libraries reliably, requiring libgcc.a to resolve some of ++ # the object symbols generated in some cases. Libraries that use ++ # assert need libgcc.a to resolve __eprintf, for example. Linking ++ # a copy of libgcc.a into every shared library to guarantee resolving ++ # such symbols causes other problems: According to Tim Van Holder ++ # , C++ libraries end up with a separate ++ # (to the application) exception stack for one thing. ++ no_undefined_flag=' -z defs' ++ if test "$GCC" = yes; then ++ case `$CC --version 2>/dev/null` in ++ [12].*) ++ cat <&2 ++ ++*** Warning: Releases of GCC earlier than version 3.0 cannot reliably ++*** create self contained shared libraries on Solaris systems, without ++*** introducing a dependency on libgcc.a. Therefore, libtool is disabling ++*** -no-undefined support, which will at least allow you to build shared ++*** libraries. However, you may find that when you link such libraries ++*** into an application without using GCC, you have to manually add ++*** \`gcc --print-libgcc-file-name\` to the link command. We urge you to ++*** upgrade to a newer version of GCC. Another option is to rebuild your ++*** current GCC to use the GNU linker from GNU binutils 2.9.1 or newer. ++ ++EOF ++ no_undefined_flag= ++ ;; ++ esac ++ fi ++ # $CC -shared without GNU ld will not create a library from C++ ++ # object files and a static libstdc++, better avoid it by now ++ archive_cmds='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags' ++ archive_expsym_cmds='$echo "{ global:" > $lib.exp~cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~ ++ $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp' ++ hardcode_libdir_flag_spec='-R$libdir' ++ hardcode_shlibpath_var=no ++ case $host_os in ++ solaris2.[0-5] | solaris2.[0-5].*) ;; ++ *) # Supported since Solaris 2.6 (maybe 2.5.1?) ++ whole_archive_flag_spec='-z allextract$convenience -z defaultextract' ;; ++ esac ++ link_all_deplibs=yes ++ ;; ++ ++ sunos4*) ++ if test "x$host_vendor" = xsequent; then ++ # Use $CC to link under sequent, because it throws in some extra .o ++ # files that make .init and .fini sections work. ++ archive_cmds='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags' ++ else ++ archive_cmds='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags' ++ fi ++ hardcode_libdir_flag_spec='-L$libdir' ++ hardcode_direct=yes ++ hardcode_minus_L=yes ++ hardcode_shlibpath_var=no ++ ;; ++ ++ sysv4) ++ if test "x$host_vendor" = xsno; then ++ archive_cmds='$LD -G -Bsymbolic -h $soname -o $lib $libobjs $deplibs $linker_flags' ++ hardcode_direct=yes # is this really true??? ++ else ++ archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' ++ hardcode_direct=no #Motorola manual says yes, but my tests say they lie ++ fi ++ runpath_var='LD_RUN_PATH' ++ hardcode_shlibpath_var=no ++ ;; ++ ++ sysv4.3*) ++ archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' ++ hardcode_shlibpath_var=no ++ export_dynamic_flag_spec='-Bexport' ++ ;; ++ ++ sysv5*) ++ no_undefined_flag=' -z text' ++ # $CC -shared without GNU ld will not create a library from C++ ++ # object files and a static libstdc++, better avoid it by now ++ archive_cmds='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags' ++ archive_expsym_cmds='$echo "{ global:" > $lib.exp~cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~ ++ $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp' ++ hardcode_libdir_flag_spec= ++ hardcode_shlibpath_var=no ++ runpath_var='LD_RUN_PATH' ++ ;; ++ ++ uts4*) ++ archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' ++ hardcode_libdir_flag_spec='-L$libdir' ++ hardcode_shlibpath_var=no ++ ;; ++ ++ dgux*) ++ archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' ++ hardcode_libdir_flag_spec='-L$libdir' ++ hardcode_shlibpath_var=no ++ ;; ++ ++ sysv4*MP*) ++ if test -d /usr/nec; then ++ archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' ++ hardcode_shlibpath_var=no ++ runpath_var=LD_RUN_PATH ++ hardcode_runpath_var=yes ++ ld_shlibs=yes ++ fi ++ ;; ++ ++ sysv4.2uw2*) ++ archive_cmds='$LD -G -o $lib $libobjs $deplibs $linker_flags' ++ hardcode_direct=yes ++ hardcode_minus_L=no ++ hardcode_shlibpath_var=no ++ hardcode_runpath_var=yes ++ runpath_var=LD_RUN_PATH ++ ;; ++ ++ sysv5uw7* | unixware7*) ++ no_undefined_flag='${wl}-z ${wl}text' ++ if test "$GCC" = yes; then ++ archive_cmds='$CC -shared ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' ++ else ++ archive_cmds='$CC -G ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' ++ fi ++ runpath_var='LD_RUN_PATH' ++ hardcode_shlibpath_var=no ++ ;; ++ ++ *) ++ ld_shlibs=no ++ ;; ++ esac ++fi ++echo "$as_me:$LINENO: result: $ld_shlibs" >&5 ++echo "${ECHO_T}$ld_shlibs" >&6 ++test "$ld_shlibs" = no && can_build_shared=no ++ ++# Check hardcoding attributes. ++echo "$as_me:$LINENO: checking how to hardcode library paths into programs" >&5 ++echo $ECHO_N "checking how to hardcode library paths into programs... $ECHO_C" >&6 ++hardcode_action= ++if test -n "$hardcode_libdir_flag_spec" || \ ++ test -n "$runpath_var"; then ++ ++ # We can hardcode non-existant directories. ++ if test "$hardcode_direct" != no && ++ # If the only mechanism to avoid hardcoding is shlibpath_var, we ++ # have to relink, otherwise we might link with an installed library ++ # when we should be linking with a yet-to-be-installed one ++ ## test "$hardcode_shlibpath_var" != no && ++ test "$hardcode_minus_L" != no; then ++ # Linking always hardcodes the temporary library directory. ++ hardcode_action=relink ++ else ++ # We can link without hardcoding, and we can hardcode nonexisting dirs. ++ hardcode_action=immediate ++ fi ++else ++ # We cannot hardcode anything, or else we can only hardcode existing ++ # directories. ++ hardcode_action=unsupported ++fi ++echo "$as_me:$LINENO: result: $hardcode_action" >&5 ++echo "${ECHO_T}$hardcode_action" >&6 ++ ++striplib= ++old_striplib= ++echo "$as_me:$LINENO: checking whether stripping libraries is possible" >&5 ++echo $ECHO_N "checking whether stripping libraries is possible... $ECHO_C" >&6 ++if test -n "$STRIP" && $STRIP -V 2>&1 | grep "GNU strip" >/dev/null; then ++ test -z "$old_striplib" && old_striplib="$STRIP --strip-debug" ++ test -z "$striplib" && striplib="$STRIP --strip-unneeded" ++ echo "$as_me:$LINENO: result: yes" >&5 ++echo "${ECHO_T}yes" >&6 ++else ++ echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6 ++fi ++ ++reload_cmds='$LD$reload_flag -o $output$reload_objs' ++test -z "$deplibs_check_method" && deplibs_check_method=unknown ++ ++# PORTME Fill in your ld.so characteristics ++echo "$as_me:$LINENO: checking dynamic linker characteristics" >&5 ++echo $ECHO_N "checking dynamic linker characteristics... $ECHO_C" >&6 ++library_names_spec= ++libname_spec='lib$name' ++soname_spec= ++postinstall_cmds= ++postuninstall_cmds= ++finish_cmds= ++finish_eval= ++shlibpath_var= ++shlibpath_overrides_runpath=unknown ++version_type=none ++dynamic_linker="$host_os ld.so" ++sys_lib_dlsearch_path_spec="/lib /usr/lib" ++sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib" ++ ++case $host_os in ++aix3*) ++ version_type=linux ++ library_names_spec='${libname}${release}.so$versuffix $libname.a' ++ shlibpath_var=LIBPATH ++ ++ # AIX has no versioning support, so we append a major version to the name. ++ soname_spec='${libname}${release}.so$major' ++ ;; ++ ++aix4* | aix5*) ++ version_type=linux ++ if test "$host_cpu" = ia64; then ++ # AIX 5 supports IA64 ++ library_names_spec='${libname}${release}.so$major ${libname}${release}.so$versuffix $libname.so' ++ shlibpath_var=LD_LIBRARY_PATH ++ else ++ # With GCC up to 2.95.x, collect2 would create an import file ++ # for dependence libraries. The import file would start with ++ # the line `#! .'. This would cause the generated library to ++ # depend on `.', always an invalid library. This was fixed in ++ # development snapshots of GCC prior to 3.0. ++ case $host_os in ++ aix4 | aix4.[01] | aix4.[01].*) ++ if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)' ++ echo ' yes ' ++ echo '#endif'; } | ${CC} -E - | grep yes > /dev/null; then ++ : ++ else ++ can_build_shared=no ++ fi ++ ;; ++ esac ++ # AIX (on Power*) has no versioning support, so currently we can ++ # not hardcode correct soname into executable. Probably we can ++ # add versioning support to collect2, so additional links can ++ # be useful in future. ++ if test "$aix_use_runtimelinking" = yes; then ++ # If using run time linking (on AIX 4.2 or later) use lib.so ++ # instead of lib.a to let people know that these are not ++ # typical AIX shared libraries. ++ library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so' ++ else ++ # We preserve .a as extension for shared libraries through AIX4.2 ++ # and later when we are not doing run time linking. ++ library_names_spec='${libname}${release}.a $libname.a' ++ soname_spec='${libname}${release}.so$major' ++ fi ++ shlibpath_var=LIBPATH ++ fi ++ ;; ++ ++amigaos*) ++ library_names_spec='$libname.ixlibrary $libname.a' ++ # Create ${libname}_ixlibrary.a entries in /sys/libs. ++ finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`$echo "X$lib" | $Xsed -e '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $rm /sys/libs/${libname}_ixlibrary.a; $show "(cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a)"; (cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a) || exit 1; done' ++ ;; ++ ++beos*) ++ library_names_spec='${libname}.so' ++ dynamic_linker="$host_os ld.so" ++ shlibpath_var=LIBRARY_PATH ++ ;; ++ ++bsdi4*) ++ version_type=linux ++ need_version=no ++ library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so' ++ soname_spec='${libname}${release}.so$major' ++ finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir' ++ shlibpath_var=LD_LIBRARY_PATH ++ sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib" ++ sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib" ++ export_dynamic_flag_spec=-rdynamic ++ # the default ld.so.conf also contains /usr/contrib/lib and ++ # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow ++ # libtool to hard-code these into programs ++ ;; ++ ++cygwin* | mingw* | pw32*) ++ version_type=windows ++ need_version=no ++ need_lib_prefix=no ++ case $GCC,$host_os in ++ yes,cygwin*) ++ library_names_spec='$libname.dll.a' ++ soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | sed -e 's/[.]/-/g'`${versuffix}.dll' ++ postinstall_cmds='dlpath=`bash 2>&1 -c '\''. $dir/${file}i;echo \$dlname'\''`~ ++ dldir=$destdir/`dirname \$dlpath`~ ++ test -d \$dldir || mkdir -p \$dldir~ ++ $install_prog .libs/$dlname \$dldir/$dlname' ++ postuninstall_cmds='dldll=`bash 2>&1 -c '\''. $file; echo \$dlname'\''`~ ++ dlpath=$dir/\$dldll~ ++ $rm \$dlpath' ++ ;; ++ yes,mingw*) ++ library_names_spec='${libname}`echo ${release} | sed -e 's/[.]/-/g'`${versuffix}.dll' ++ sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | sed -e "s/^libraries://" -e "s/;/ /g"` ++ ;; ++ yes,pw32*) ++ library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | sed -e 's/./-/g'`${versuffix}.dll' ++ ;; ++ *) ++ library_names_spec='${libname}`echo ${release} | sed -e 's/[.]/-/g'`${versuffix}.dll $libname.lib' ++ ;; ++ esac ++ dynamic_linker='Win32 ld.exe' ++ # FIXME: first we should search . and the directory the executable is in ++ shlibpath_var=PATH ++ ;; ++ ++darwin* | rhapsody*) ++ dynamic_linker="$host_os dyld" ++ version_type=darwin ++ need_lib_prefix=no ++ need_version=no ++ # FIXME: Relying on posixy $() will cause problems for ++ # cross-compilation, but unfortunately the echo tests do not ++ # yet detect zsh echo's removal of \ escapes. ++ library_names_spec='${libname}${release}${versuffix}.$(test .$module = .yes && echo so || echo dylib) ${libname}${release}${major}.$(test .$module = .yes && echo so || echo dylib) ${libname}.$(test .$module = .yes && echo so || echo dylib)' ++ soname_spec='${libname}${release}${major}.$(test .$module = .yes && echo so || echo dylib)' ++ shlibpath_overrides_runpath=yes ++ shlibpath_var=DYLD_LIBRARY_PATH ++ ;; ++ ++freebsd1*) ++ dynamic_linker=no ++ ;; ++ ++freebsd*) ++ objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo aout` ++ version_type=freebsd-$objformat ++ case $version_type in ++ freebsd-elf*) ++ library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so $libname.so' ++ need_version=no ++ need_lib_prefix=no ++ ;; ++ freebsd-*) ++ library_names_spec='${libname}${release}.so$versuffix $libname.so$versuffix' ++ need_version=yes ++ ;; ++ esac ++ shlibpath_var=LD_LIBRARY_PATH ++ case $host_os in ++ freebsd2*) ++ shlibpath_overrides_runpath=yes ++ ;; ++ *) ++ shlibpath_overrides_runpath=no ++ hardcode_into_libs=yes ++ ;; ++ esac ++ ;; ++ ++gnu*) ++ version_type=linux ++ need_lib_prefix=no ++ need_version=no ++ library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so${major} ${libname}.so' ++ soname_spec='${libname}${release}.so$major' ++ shlibpath_var=LD_LIBRARY_PATH ++ hardcode_into_libs=yes ++ ;; ++ ++hpux9* | hpux10* | hpux11*) ++ # Give a soname corresponding to the major version so that dld.sl refuses to ++ # link against other versions. ++ dynamic_linker="$host_os dld.sl" ++ version_type=sunos ++ need_lib_prefix=no ++ need_version=no ++ shlibpath_var=SHLIB_PATH ++ shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH ++ library_names_spec='${libname}${release}.sl$versuffix ${libname}${release}.sl$major $libname.sl' ++ soname_spec='${libname}${release}.sl$major' ++ # HP-UX runs *really* slowly unless shared libraries are mode 555. ++ postinstall_cmds='chmod 555 $lib' ++ ;; ++ ++irix5* | irix6*) ++ version_type=irix ++ need_lib_prefix=no ++ need_version=no ++ soname_spec='${libname}${release}.so$major' ++ library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major ${libname}${release}.so $libname.so' ++ case $host_os in ++ irix5*) ++ libsuff= shlibsuff= ++ ;; ++ *) ++ case $LD in # libtool.m4 will add one of these switches to LD ++ *-32|*"-32 ") libsuff= shlibsuff= libmagic=32-bit;; ++ *-n32|*"-n32 ") libsuff=32 shlibsuff=N32 libmagic=N32;; ++ *-64|*"-64 ") libsuff=64 shlibsuff=64 libmagic=64-bit;; ++ *) libsuff= shlibsuff= libmagic=never-match;; ++ esac ++ ;; ++ esac ++ shlibpath_var=LD_LIBRARY${shlibsuff}_PATH ++ shlibpath_overrides_runpath=no ++ sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}" ++ sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}" ++ ;; ++ ++# No shared lib support for Linux oldld, aout, or coff. ++linux-gnuoldld* | linux-gnuaout* | linux-gnucoff*) ++ dynamic_linker=no ++ ;; ++ ++# This must be Linux ELF. ++linux-gnu*) ++ version_type=linux ++ need_lib_prefix=no ++ need_version=no ++ library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so' ++ soname_spec='${libname}${release}.so$major' ++ finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir' ++ shlibpath_var=LD_LIBRARY_PATH ++ shlibpath_overrides_runpath=no ++ # This implies no fast_install, which is unacceptable. ++ # Some rework will be needed to allow for fast_install ++ # before this can be enabled. ++ hardcode_into_libs=yes ++ ++ # We used to test for /lib/ld.so.1 and disable shared libraries on ++ # powerpc, because MkLinux only supported shared libraries with the ++ # GNU dynamic linker. Since this was broken with cross compilers, ++ # most powerpc-linux boxes support dynamic linking these days and ++ # people can always --disable-shared, the test was removed, and we ++ # assume the GNU/Linux dynamic linker is in use. ++ dynamic_linker='GNU/Linux ld.so' ++ ;; ++ ++netbsd*) ++ version_type=sunos ++ need_lib_prefix=no ++ need_version=no ++ if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then ++ library_names_spec='${libname}${release}.so$versuffix ${libname}.so$versuffix' ++ finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' ++ dynamic_linker='NetBSD (a.out) ld.so' ++ else ++ library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major ${libname}${release}.so ${libname}.so' ++ soname_spec='${libname}${release}.so$major' ++ dynamic_linker='NetBSD ld.elf_so' ++ fi ++ shlibpath_var=LD_LIBRARY_PATH ++ shlibpath_overrides_runpath=yes ++ hardcode_into_libs=yes ++ ;; ++ ++newsos6) ++ version_type=linux ++ library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so' ++ shlibpath_var=LD_LIBRARY_PATH ++ shlibpath_overrides_runpath=yes ++ ;; ++ ++openbsd*) ++ version_type=sunos ++ need_lib_prefix=no ++ need_version=no ++ if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then ++ case "$host_os" in ++ openbsd2.[89] | openbsd2.[89].*) ++ shlibpath_overrides_runpath=no ++ ;; ++ *) ++ shlibpath_overrides_runpath=yes ++ ;; ++ esac ++ else ++ shlibpath_overrides_runpath=yes ++ fi ++ library_names_spec='${libname}${release}.so$versuffix ${libname}.so$versuffix' ++ finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' ++ shlibpath_var=LD_LIBRARY_PATH ++ ;; ++ ++os2*) ++ libname_spec='$name' ++ need_lib_prefix=no ++ library_names_spec='$libname.dll $libname.a' ++ dynamic_linker='OS/2 ld.exe' ++ shlibpath_var=LIBPATH ++ ;; ++ ++osf3* | osf4* | osf5*) ++ version_type=osf ++ need_version=no ++ soname_spec='${libname}${release}.so' ++ library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so $libname.so' ++ shlibpath_var=LD_LIBRARY_PATH ++ sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib" ++ sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec" ++ ;; ++ ++sco3.2v5*) ++ version_type=osf ++ soname_spec='${libname}${release}.so$major' ++ library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so' ++ shlibpath_var=LD_LIBRARY_PATH ++ ;; ++ ++solaris*) ++ version_type=linux ++ need_lib_prefix=no ++ need_version=no ++ library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so' ++ soname_spec='${libname}${release}.so$major' ++ shlibpath_var=LD_LIBRARY_PATH ++ shlibpath_overrides_runpath=yes ++ hardcode_into_libs=yes ++ # ldd complains unless libraries are executable ++ postinstall_cmds='chmod +x $lib' ++ ;; ++ ++sunos4*) ++ version_type=sunos ++ library_names_spec='${libname}${release}.so$versuffix ${libname}.so$versuffix' ++ finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir' ++ shlibpath_var=LD_LIBRARY_PATH ++ shlibpath_overrides_runpath=yes ++ if test "$with_gnu_ld" = yes; then ++ need_lib_prefix=no ++ fi ++ need_version=yes ++ ;; ++ ++sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) ++ version_type=linux ++ library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so' ++ soname_spec='${libname}${release}.so$major' ++ shlibpath_var=LD_LIBRARY_PATH ++ case $host_vendor in ++ sni) ++ shlibpath_overrides_runpath=no ++ ;; ++ motorola) ++ need_lib_prefix=no ++ need_version=no ++ shlibpath_overrides_runpath=no ++ sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib' ++ ;; ++ esac ++ ;; ++ ++uts4*) ++ version_type=linux ++ library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so' ++ soname_spec='${libname}${release}.so$major' ++ shlibpath_var=LD_LIBRARY_PATH ++ ;; ++ ++dgux*) ++ version_type=linux ++ need_lib_prefix=no ++ need_version=no ++ library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so' ++ soname_spec='${libname}${release}.so$major' ++ shlibpath_var=LD_LIBRARY_PATH ++ ;; ++ ++sysv4*MP*) ++ if test -d /usr/nec ;then ++ version_type=linux ++ library_names_spec='$libname.so.$versuffix $libname.so.$major $libname.so' ++ soname_spec='$libname.so.$major' ++ shlibpath_var=LD_LIBRARY_PATH ++ fi ++ ;; ++ ++*) ++ dynamic_linker=no ++ ;; ++esac ++echo "$as_me:$LINENO: result: $dynamic_linker" >&5 ++echo "${ECHO_T}$dynamic_linker" >&6 ++test "$dynamic_linker" = no && can_build_shared=no ++ ++# Report the final consequences. ++echo "$as_me:$LINENO: checking if libtool supports shared libraries" >&5 ++echo $ECHO_N "checking if libtool supports shared libraries... $ECHO_C" >&6 ++echo "$as_me:$LINENO: result: $can_build_shared" >&5 ++echo "${ECHO_T}$can_build_shared" >&6 ++ ++echo "$as_me:$LINENO: checking whether to build shared libraries" >&5 ++echo $ECHO_N "checking whether to build shared libraries... $ECHO_C" >&6 ++test "$can_build_shared" = "no" && enable_shared=no ++ ++# On AIX, shared libraries and static libraries use the same namespace, and ++# are all built from PIC. ++case "$host_os" in ++aix3*) ++ test "$enable_shared" = yes && enable_static=no ++ if test -n "$RANLIB"; then ++ archive_cmds="$archive_cmds~\$RANLIB \$lib" ++ postinstall_cmds='$RANLIB $lib' ++ fi ++ ;; ++ ++aix4*) ++ if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then ++ test "$enable_shared" = yes && enable_static=no ++ fi ++ ;; ++esac ++echo "$as_me:$LINENO: result: $enable_shared" >&5 ++echo "${ECHO_T}$enable_shared" >&6 ++ ++echo "$as_me:$LINENO: checking whether to build static libraries" >&5 ++echo $ECHO_N "checking whether to build static libraries... $ECHO_C" >&6 ++# Make sure either enable_shared or enable_static is yes. ++test "$enable_shared" = yes || enable_static=yes ++echo "$as_me:$LINENO: result: $enable_static" >&5 ++echo "${ECHO_T}$enable_static" >&6 ++ ++if test "$hardcode_action" = relink; then ++ # Fast installation is not supported ++ enable_fast_install=no ++elif test "$shlibpath_overrides_runpath" = yes || ++ test "$enable_shared" = no; then ++ # Fast installation is not necessary ++ enable_fast_install=needless ++fi ++ ++variables_saved_for_relink="PATH $shlibpath_var $runpath_var" ++if test "$GCC" = yes; then ++ variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" ++fi ++ ++if test "x$enable_dlopen" != xyes; then ++ enable_dlopen=unknown ++ enable_dlopen_self=unknown ++ enable_dlopen_self_static=unknown ++else ++ lt_cv_dlopen=no ++ lt_cv_dlopen_libs= ++ ++ case $host_os in ++ beos*) ++ lt_cv_dlopen="load_add_on" ++ lt_cv_dlopen_libs= ++ lt_cv_dlopen_self=yes ++ ;; ++ ++ cygwin* | mingw* | pw32*) ++ lt_cv_dlopen="LoadLibrary" ++ lt_cv_dlopen_libs= ++ ;; ++ ++ *) ++ echo "$as_me:$LINENO: checking for shl_load" >&5 ++echo $ECHO_N "checking for shl_load... $ECHO_C" >&6 ++if test "${ac_cv_func_shl_load+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++#include "confdefs.h" ++/* System header to define __stub macros and hopefully few prototypes, ++ which can conflict with char shl_load (); below. */ ++#include ++/* Override any gcc2 internal prototype to avoid an error. */ ++#ifdef __cplusplus ++extern "C" ++#endif ++/* We use char because int might match the return type of a gcc2 ++ builtin and then its argument prototype would still apply. */ ++char shl_load (); ++char (*f) (); ++ ++int ++main () ++{ ++/* The GNU C library defines this for functions which it implements ++ to always fail with ENOSYS. Some functions are actually named ++ something starting with __ and the normal name is an alias. */ ++#if defined (__stub_shl_load) || defined (__stub___shl_load) ++choke me ++#else ++f = shl_load; ++#endif ++ ++ ; ++ return 0; ++} ++_ACEOF ++rm -f conftest.$ac_objext conftest$ac_exeext ++if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 ++ (eval $ac_link) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && ++ { ac_try='test -s conftest$ac_exeext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ ac_cv_func_shl_load=yes ++else ++ echo "$as_me: failed program was:" >&5 ++cat conftest.$ac_ext >&5 ++ac_cv_func_shl_load=no ++fi ++rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext ++fi ++echo "$as_me:$LINENO: result: $ac_cv_func_shl_load" >&5 ++echo "${ECHO_T}$ac_cv_func_shl_load" >&6 ++if test $ac_cv_func_shl_load = yes; then ++ lt_cv_dlopen="shl_load" ++else ++ echo "$as_me:$LINENO: checking for shl_load in -ldld" >&5 ++echo $ECHO_N "checking for shl_load in -ldld... $ECHO_C" >&6 ++if test "${ac_cv_lib_dld_shl_load+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ ac_check_lib_save_LIBS=$LIBS ++LIBS="-ldld $LIBS" ++cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++#include "confdefs.h" ++ ++/* Override any gcc2 internal prototype to avoid an error. */ ++#ifdef __cplusplus ++extern "C" ++#endif ++/* We use char because int might match the return type of a gcc2 ++ builtin and then its argument prototype would still apply. */ ++char shl_load (); ++int ++main () ++{ ++shl_load (); ++ ; ++ return 0; ++} ++_ACEOF ++rm -f conftest.$ac_objext conftest$ac_exeext ++if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 ++ (eval $ac_link) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && ++ { ac_try='test -s conftest$ac_exeext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ ac_cv_lib_dld_shl_load=yes ++else ++ echo "$as_me: failed program was:" >&5 ++cat conftest.$ac_ext >&5 ++ac_cv_lib_dld_shl_load=no ++fi ++rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext ++LIBS=$ac_check_lib_save_LIBS ++fi ++echo "$as_me:$LINENO: result: $ac_cv_lib_dld_shl_load" >&5 ++echo "${ECHO_T}$ac_cv_lib_dld_shl_load" >&6 ++if test $ac_cv_lib_dld_shl_load = yes; then ++ lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-dld" ++else ++ echo "$as_me:$LINENO: checking for dlopen" >&5 ++echo $ECHO_N "checking for dlopen... $ECHO_C" >&6 ++if test "${ac_cv_func_dlopen+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++#include "confdefs.h" ++/* System header to define __stub macros and hopefully few prototypes, ++ which can conflict with char dlopen (); below. */ ++#include ++/* Override any gcc2 internal prototype to avoid an error. */ ++#ifdef __cplusplus ++extern "C" ++#endif ++/* We use char because int might match the return type of a gcc2 ++ builtin and then its argument prototype would still apply. */ ++char dlopen (); ++char (*f) (); ++ ++int ++main () ++{ ++/* The GNU C library defines this for functions which it implements ++ to always fail with ENOSYS. Some functions are actually named ++ something starting with __ and the normal name is an alias. */ ++#if defined (__stub_dlopen) || defined (__stub___dlopen) ++choke me ++#else ++f = dlopen; ++#endif ++ ++ ; ++ return 0; ++} ++_ACEOF ++rm -f conftest.$ac_objext conftest$ac_exeext ++if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 ++ (eval $ac_link) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && ++ { ac_try='test -s conftest$ac_exeext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ ac_cv_func_dlopen=yes ++else ++ echo "$as_me: failed program was:" >&5 ++cat conftest.$ac_ext >&5 ++ac_cv_func_dlopen=no ++fi ++rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext ++fi ++echo "$as_me:$LINENO: result: $ac_cv_func_dlopen" >&5 ++echo "${ECHO_T}$ac_cv_func_dlopen" >&6 ++if test $ac_cv_func_dlopen = yes; then ++ lt_cv_dlopen="dlopen" ++else ++ echo "$as_me:$LINENO: checking for dlopen in -ldl" >&5 ++echo $ECHO_N "checking for dlopen in -ldl... $ECHO_C" >&6 ++if test "${ac_cv_lib_dl_dlopen+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ ac_check_lib_save_LIBS=$LIBS ++LIBS="-ldl $LIBS" ++cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++#include "confdefs.h" ++ ++/* Override any gcc2 internal prototype to avoid an error. */ ++#ifdef __cplusplus ++extern "C" ++#endif ++/* We use char because int might match the return type of a gcc2 ++ builtin and then its argument prototype would still apply. */ ++char dlopen (); ++int ++main () ++{ ++dlopen (); ++ ; ++ return 0; ++} ++_ACEOF ++rm -f conftest.$ac_objext conftest$ac_exeext ++if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 ++ (eval $ac_link) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && ++ { ac_try='test -s conftest$ac_exeext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ ac_cv_lib_dl_dlopen=yes ++else ++ echo "$as_me: failed program was:" >&5 ++cat conftest.$ac_ext >&5 ++ac_cv_lib_dl_dlopen=no ++fi ++rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext ++LIBS=$ac_check_lib_save_LIBS ++fi ++echo "$as_me:$LINENO: result: $ac_cv_lib_dl_dlopen" >&5 ++echo "${ECHO_T}$ac_cv_lib_dl_dlopen" >&6 ++if test $ac_cv_lib_dl_dlopen = yes; then ++ lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl" ++else ++ echo "$as_me:$LINENO: checking for dlopen in -lsvld" >&5 ++echo $ECHO_N "checking for dlopen in -lsvld... $ECHO_C" >&6 ++if test "${ac_cv_lib_svld_dlopen+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ ac_check_lib_save_LIBS=$LIBS ++LIBS="-lsvld $LIBS" ++cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++#include "confdefs.h" ++ ++/* Override any gcc2 internal prototype to avoid an error. */ ++#ifdef __cplusplus ++extern "C" ++#endif ++/* We use char because int might match the return type of a gcc2 ++ builtin and then its argument prototype would still apply. */ ++char dlopen (); ++int ++main () ++{ ++dlopen (); ++ ; ++ return 0; ++} ++_ACEOF ++rm -f conftest.$ac_objext conftest$ac_exeext ++if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 ++ (eval $ac_link) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && ++ { ac_try='test -s conftest$ac_exeext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ ac_cv_lib_svld_dlopen=yes ++else ++ echo "$as_me: failed program was:" >&5 ++cat conftest.$ac_ext >&5 ++ac_cv_lib_svld_dlopen=no ++fi ++rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext ++LIBS=$ac_check_lib_save_LIBS ++fi ++echo "$as_me:$LINENO: result: $ac_cv_lib_svld_dlopen" >&5 ++echo "${ECHO_T}$ac_cv_lib_svld_dlopen" >&6 ++if test $ac_cv_lib_svld_dlopen = yes; then ++ lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld" ++else ++ echo "$as_me:$LINENO: checking for dld_link in -ldld" >&5 ++echo $ECHO_N "checking for dld_link in -ldld... $ECHO_C" >&6 ++if test "${ac_cv_lib_dld_dld_link+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ ac_check_lib_save_LIBS=$LIBS ++LIBS="-ldld $LIBS" ++cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++#include "confdefs.h" ++ ++/* Override any gcc2 internal prototype to avoid an error. */ ++#ifdef __cplusplus ++extern "C" ++#endif ++/* We use char because int might match the return type of a gcc2 ++ builtin and then its argument prototype would still apply. */ ++char dld_link (); ++int ++main () ++{ ++dld_link (); ++ ; ++ return 0; ++} ++_ACEOF ++rm -f conftest.$ac_objext conftest$ac_exeext ++if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 ++ (eval $ac_link) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && ++ { ac_try='test -s conftest$ac_exeext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ ac_cv_lib_dld_dld_link=yes ++else ++ echo "$as_me: failed program was:" >&5 ++cat conftest.$ac_ext >&5 ++ac_cv_lib_dld_dld_link=no ++fi ++rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext ++LIBS=$ac_check_lib_save_LIBS ++fi ++echo "$as_me:$LINENO: result: $ac_cv_lib_dld_dld_link" >&5 ++echo "${ECHO_T}$ac_cv_lib_dld_dld_link" >&6 ++if test $ac_cv_lib_dld_dld_link = yes; then ++ lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-dld" ++fi ++ ++ ++fi ++ ++ ++fi ++ ++ ++fi ++ ++ ++fi ++ ++ ++fi ++ ++ ;; ++ esac ++ ++ if test "x$lt_cv_dlopen" != xno; then ++ enable_dlopen=yes ++ else ++ enable_dlopen=no ++ fi ++ ++ case $lt_cv_dlopen in ++ dlopen) ++ save_CPPFLAGS="$CPPFLAGS" ++ test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H" ++ ++ save_LDFLAGS="$LDFLAGS" ++ eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\" ++ ++ save_LIBS="$LIBS" ++ LIBS="$lt_cv_dlopen_libs $LIBS" ++ ++ echo "$as_me:$LINENO: checking whether a program can dlopen itself" >&5 ++echo $ECHO_N "checking whether a program can dlopen itself... $ECHO_C" >&6 ++if test "${lt_cv_dlopen_self+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test "$cross_compiling" = yes; then : ++ lt_cv_dlopen_self=cross ++else ++ lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 ++ lt_status=$lt_dlunknown ++ cat > conftest.$ac_ext < ++#endif ++ ++#include ++ ++#ifdef RTLD_GLOBAL ++# define LT_DLGLOBAL RTLD_GLOBAL ++#else ++# ifdef DL_GLOBAL ++# define LT_DLGLOBAL DL_GLOBAL ++# else ++# define LT_DLGLOBAL 0 ++# endif ++#endif ++ ++/* We may have to define LT_DLLAZY_OR_NOW in the command line if we ++ find out it does not work in some platform. */ ++#ifndef LT_DLLAZY_OR_NOW ++# ifdef RTLD_LAZY ++# define LT_DLLAZY_OR_NOW RTLD_LAZY ++# else ++# ifdef DL_LAZY ++# define LT_DLLAZY_OR_NOW DL_LAZY ++# else ++# ifdef RTLD_NOW ++# define LT_DLLAZY_OR_NOW RTLD_NOW ++# else ++# ifdef DL_NOW ++# define LT_DLLAZY_OR_NOW DL_NOW ++# else ++# define LT_DLLAZY_OR_NOW 0 ++# endif ++# endif ++# endif ++# endif ++#endif ++ ++#ifdef __cplusplus ++extern "C" void exit (int); ++#endif ++ ++void fnord() { int i=42;} ++int main () ++{ ++ void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW); ++ int status = $lt_dlunknown; ++ ++ if (self) ++ { ++ if (dlsym (self,"fnord")) status = $lt_dlno_uscore; ++ else if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore; ++ /* dlclose (self); */ ++ } ++ ++ exit (status); ++} ++EOF ++ if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 ++ (eval $ac_link) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && test -s conftest${ac_exeext} 2>/dev/null; then ++ (./conftest; exit; ) 2>/dev/null ++ lt_status=$? ++ case x$lt_status in ++ x$lt_dlno_uscore) lt_cv_dlopen_self=yes ;; ++ x$lt_dlneed_uscore) lt_cv_dlopen_self=yes ;; ++ x$lt_unknown|x*) lt_cv_dlopen_self=no ;; ++ esac ++ else : ++ # compilation failed ++ lt_cv_dlopen_self=no ++ fi ++fi ++rm -fr conftest* ++ ++ ++fi ++echo "$as_me:$LINENO: result: $lt_cv_dlopen_self" >&5 ++echo "${ECHO_T}$lt_cv_dlopen_self" >&6 ++ ++ if test "x$lt_cv_dlopen_self" = xyes; then ++ LDFLAGS="$LDFLAGS $link_static_flag" ++ echo "$as_me:$LINENO: checking whether a statically linked program can dlopen itself" >&5 ++echo $ECHO_N "checking whether a statically linked program can dlopen itself... $ECHO_C" >&6 ++if test "${lt_cv_dlopen_self_static+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if test "$cross_compiling" = yes; then : ++ lt_cv_dlopen_self_static=cross ++else ++ lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 ++ lt_status=$lt_dlunknown ++ cat > conftest.$ac_ext < ++#endif ++ ++#include ++ ++#ifdef RTLD_GLOBAL ++# define LT_DLGLOBAL RTLD_GLOBAL ++#else ++# ifdef DL_GLOBAL ++# define LT_DLGLOBAL DL_GLOBAL ++# else ++# define LT_DLGLOBAL 0 ++# endif ++#endif ++ ++/* We may have to define LT_DLLAZY_OR_NOW in the command line if we ++ find out it does not work in some platform. */ ++#ifndef LT_DLLAZY_OR_NOW ++# ifdef RTLD_LAZY ++# define LT_DLLAZY_OR_NOW RTLD_LAZY ++# else ++# ifdef DL_LAZY ++# define LT_DLLAZY_OR_NOW DL_LAZY ++# else ++# ifdef RTLD_NOW ++# define LT_DLLAZY_OR_NOW RTLD_NOW ++# else ++# ifdef DL_NOW ++# define LT_DLLAZY_OR_NOW DL_NOW ++# else ++# define LT_DLLAZY_OR_NOW 0 ++# endif ++# endif ++# endif ++# endif ++#endif ++ ++#ifdef __cplusplus ++extern "C" void exit (int); ++#endif ++ ++void fnord() { int i=42;} ++int main () ++{ ++ void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW); ++ int status = $lt_dlunknown; ++ ++ if (self) ++ { ++ if (dlsym (self,"fnord")) status = $lt_dlno_uscore; ++ else if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore; ++ /* dlclose (self); */ ++ } ++ ++ exit (status); ++} ++EOF ++ if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 ++ (eval $ac_link) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && test -s conftest${ac_exeext} 2>/dev/null; then ++ (./conftest; exit; ) 2>/dev/null ++ lt_status=$? ++ case x$lt_status in ++ x$lt_dlno_uscore) lt_cv_dlopen_self_static=yes ;; ++ x$lt_dlneed_uscore) lt_cv_dlopen_self_static=yes ;; ++ x$lt_unknown|x*) lt_cv_dlopen_self_static=no ;; ++ esac ++ else : ++ # compilation failed ++ lt_cv_dlopen_self_static=no ++ fi ++fi ++rm -fr conftest* ++ ++ ++fi ++echo "$as_me:$LINENO: result: $lt_cv_dlopen_self_static" >&5 ++echo "${ECHO_T}$lt_cv_dlopen_self_static" >&6 ++ fi ++ ++ CPPFLAGS="$save_CPPFLAGS" ++ LDFLAGS="$save_LDFLAGS" ++ LIBS="$save_LIBS" ++ ;; ++ esac ++ ++ case $lt_cv_dlopen_self in ++ yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;; ++ *) enable_dlopen_self=unknown ;; ++ esac ++ ++ case $lt_cv_dlopen_self_static in ++ yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;; ++ *) enable_dlopen_self_static=unknown ;; ++ esac ++fi ++ ++ ++if test "$enable_shared" = yes && test "$GCC" = yes; then ++ case $archive_cmds in ++ *'~'*) ++ # FIXME: we may have to deal with multi-command sequences. ++ ;; ++ '$CC '*) ++ # Test whether the compiler implicitly links with -lc since on some ++ # systems, -lgcc has to come before -lc. If gcc already passes -lc ++ # to ld, don't add -lc before -lgcc. ++ echo "$as_me:$LINENO: checking whether -lc should be explicitly linked in" >&5 ++echo $ECHO_N "checking whether -lc should be explicitly linked in... $ECHO_C" >&6 ++ if test "${lt_cv_archive_cmds_need_lc+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ $rm conftest* ++ echo 'static int dummy;' > conftest.$ac_ext ++ ++ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 ++ (eval $ac_compile) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; then ++ soname=conftest ++ lib=conftest ++ libobjs=conftest.$ac_objext ++ deplibs= ++ wl=$lt_cv_prog_cc_wl ++ compiler_flags=-v ++ linker_flags=-v ++ verstring= ++ output_objdir=. ++ libname=conftest ++ save_allow_undefined_flag=$allow_undefined_flag ++ allow_undefined_flag= ++ if { (eval echo "$as_me:$LINENO: \"$archive_cmds 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1\"") >&5 ++ (eval $archive_cmds 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } ++ then ++ lt_cv_archive_cmds_need_lc=no ++ else ++ lt_cv_archive_cmds_need_lc=yes ++ fi ++ allow_undefined_flag=$save_allow_undefined_flag ++ else ++ cat conftest.err 1>&5 ++ fi ++fi ++ ++ echo "$as_me:$LINENO: result: $lt_cv_archive_cmds_need_lc" >&5 ++echo "${ECHO_T}$lt_cv_archive_cmds_need_lc" >&6 ++ ;; ++ esac ++fi ++need_lc=${lt_cv_archive_cmds_need_lc-yes} ++ ++# The second clause should only fire when bootstrapping the ++# libtool distribution, otherwise you forgot to ship ltmain.sh ++# with your package, and you will get complaints that there are ++# no rules to generate ltmain.sh. ++if test -f "$ltmain"; then ++ : ++else ++ # If there is no Makefile yet, we rely on a make rule to execute ++ # `config.status --recheck' to rerun these tests and create the ++ # libtool script then. ++ test -f Makefile && make "$ltmain" ++fi ++ ++if test -f "$ltmain"; then ++ trap "$rm \"${ofile}T\"; exit 1" 1 2 15 ++ $rm -f "${ofile}T" ++ ++ echo creating $ofile ++ ++ # Now quote all the things that may contain metacharacters while being ++ # careful not to overquote the AC_SUBSTed values. We take copies of the ++ # variables and quote the copies for generation of the libtool script. ++ for var in echo old_CC old_CFLAGS \ ++ AR AR_FLAGS CC LD LN_S NM SHELL \ ++ reload_flag reload_cmds wl \ ++ pic_flag link_static_flag no_builtin_flag export_dynamic_flag_spec \ ++ thread_safe_flag_spec whole_archive_flag_spec libname_spec \ ++ library_names_spec soname_spec \ ++ RANLIB old_archive_cmds old_archive_from_new_cmds old_postinstall_cmds \ ++ old_postuninstall_cmds archive_cmds archive_expsym_cmds postinstall_cmds \ ++ postuninstall_cmds extract_expsyms_cmds old_archive_from_expsyms_cmds \ ++ old_striplib striplib file_magic_cmd export_symbols_cmds \ ++ deplibs_check_method allow_undefined_flag no_undefined_flag \ ++ finish_cmds finish_eval global_symbol_pipe global_symbol_to_cdecl \ ++ global_symbol_to_c_name_address \ ++ hardcode_libdir_flag_spec hardcode_libdir_separator \ ++ sys_lib_search_path_spec sys_lib_dlsearch_path_spec \ ++ compiler_c_o compiler_o_lo need_locks exclude_expsyms include_expsyms; do ++ ++ case $var in ++ reload_cmds | old_archive_cmds | old_archive_from_new_cmds | \ ++ old_postinstall_cmds | old_postuninstall_cmds | \ ++ export_symbols_cmds | archive_cmds | archive_expsym_cmds | \ ++ extract_expsyms_cmds | old_archive_from_expsyms_cmds | \ ++ postinstall_cmds | postuninstall_cmds | \ ++ finish_cmds | sys_lib_search_path_spec | sys_lib_dlsearch_path_spec) ++ # Double-quote double-evaled strings. ++ eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$double_quote_subst\" -e \"\$sed_quote_subst\" -e \"\$delay_variable_subst\"\`\\\"" ++ ;; ++ *) ++ eval "lt_$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$sed_quote_subst\"\`\\\"" ++ ;; ++ esac ++ done ++ ++ cat <<__EOF__ > "${ofile}T" ++#! $SHELL ++ ++# `$echo "$ofile" | sed 's%^.*/%%'` - Provide generalized library-building support services. ++# Generated automatically by $PROGRAM (GNU $PACKAGE $VERSION$TIMESTAMP) ++# NOTE: Changes made to this file will be lost: look at ltmain.sh. ++# ++# Copyright (C) 1996-2000 Free Software Foundation, Inc. ++# Originally by Gordon Matzigkeit , 1996 ++# ++# This program is free software; you can redistribute it and/or modify ++# it under the terms of the GNU General Public License as published by ++# the Free Software Foundation; either version 2 of the License, or ++# (at your option) any later version. ++# ++# This program is distributed in the hope that it will be useful, but ++# WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++# General Public License for more details. ++# ++# You should have received a copy of the GNU General Public License ++# along with this program; if not, write to the Free Software ++# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. ++# ++# As a special exception to the GNU General Public License, if you ++# distribute this file as part of a program that contains a ++# configuration script generated by Autoconf, you may include it under ++# the same distribution terms that you use for the rest of that program. ++ ++# Sed that helps us avoid accidentally triggering echo(1) options like -n. ++Xsed="sed -e s/^X//" ++ ++# The HP-UX ksh and POSIX shell print the target directory to stdout ++# if CDPATH is set. ++if test "X\${CDPATH+set}" = Xset; then CDPATH=:; export CDPATH; fi ++ ++# ### BEGIN LIBTOOL CONFIG ++ ++# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`: ++ ++# Shell to use when invoking shell scripts. ++SHELL=$lt_SHELL ++ ++# Whether or not to build shared libraries. ++build_libtool_libs=$enable_shared ++ ++# Whether or not to build static libraries. ++build_old_libs=$enable_static ++ ++# Whether or not to add -lc for building shared libraries. ++build_libtool_need_lc=$need_lc ++ ++# Whether or not to optimize for fast installation. ++fast_install=$enable_fast_install ++ ++# The host system. ++host_alias=$host_alias ++host=$host ++ ++# An echo program that does not interpret backslashes. ++echo=$lt_echo ++ ++# The archiver. ++AR=$lt_AR ++AR_FLAGS=$lt_AR_FLAGS ++ ++# The default C compiler. ++CC=$lt_CC ++ ++# Is the compiler the GNU C compiler? ++with_gcc=$GCC ++ ++# The linker used to build libraries. ++LD=$lt_LD ++ ++# Whether we need hard or soft links. ++LN_S=$lt_LN_S ++ ++# A BSD-compatible nm program. ++NM=$lt_NM ++ ++# A symbol stripping program ++STRIP=$STRIP ++ ++# Used to examine libraries when file_magic_cmd begins "file" ++MAGIC_CMD=$MAGIC_CMD ++ ++# Used on cygwin: DLL creation program. ++DLLTOOL="$DLLTOOL" ++ ++# Used on cygwin: object dumper. ++OBJDUMP="$OBJDUMP" ++ ++# Used on cygwin: assembler. ++AS="$AS" ++ ++# The name of the directory that contains temporary libtool files. ++objdir=$objdir ++ ++# How to create reloadable object files. ++reload_flag=$lt_reload_flag ++reload_cmds=$lt_reload_cmds ++ ++# How to pass a linker flag through the compiler. ++wl=$lt_wl ++ ++# Object file suffix (normally "o"). ++objext="$ac_objext" ++ ++# Old archive suffix (normally "a"). ++libext="$libext" ++ ++# Executable file suffix (normally ""). ++exeext="$exeext" ++ ++# Additional compiler flags for building library objects. ++pic_flag=$lt_pic_flag ++pic_mode=$pic_mode ++ ++# Does compiler simultaneously support -c and -o options? ++compiler_c_o=$lt_compiler_c_o ++ ++# Can we write directly to a .lo ? ++compiler_o_lo=$lt_compiler_o_lo ++ ++# Must we lock files when doing compilation ? ++need_locks=$lt_need_locks ++ ++# Do we need the lib prefix for modules? ++need_lib_prefix=$need_lib_prefix ++ ++# Do we need a version for libraries? ++need_version=$need_version ++ ++# Whether dlopen is supported. ++dlopen_support=$enable_dlopen ++ ++# Whether dlopen of programs is supported. ++dlopen_self=$enable_dlopen_self ++ ++# Whether dlopen of statically linked programs is supported. ++dlopen_self_static=$enable_dlopen_self_static ++ ++# Compiler flag to prevent dynamic linking. ++link_static_flag=$lt_link_static_flag ++ ++# Compiler flag to turn off builtin functions. ++no_builtin_flag=$lt_no_builtin_flag ++ ++# Compiler flag to allow reflexive dlopens. ++export_dynamic_flag_spec=$lt_export_dynamic_flag_spec ++ ++# Compiler flag to generate shared objects directly from archives. ++whole_archive_flag_spec=$lt_whole_archive_flag_spec ++ ++# Compiler flag to generate thread-safe objects. ++thread_safe_flag_spec=$lt_thread_safe_flag_spec ++ ++# Library versioning type. ++version_type=$version_type ++ ++# Format of library name prefix. ++libname_spec=$lt_libname_spec ++ ++# List of archive names. First name is the real one, the rest are links. ++# The last name is the one that the linker finds with -lNAME. ++library_names_spec=$lt_library_names_spec ++ ++# The coded name of the library, if different from the real name. ++soname_spec=$lt_soname_spec ++ ++# Commands used to build and install an old-style archive. ++RANLIB=$lt_RANLIB ++old_archive_cmds=$lt_old_archive_cmds ++old_postinstall_cmds=$lt_old_postinstall_cmds ++old_postuninstall_cmds=$lt_old_postuninstall_cmds ++ ++# Create an old-style archive from a shared archive. ++old_archive_from_new_cmds=$lt_old_archive_from_new_cmds ++ ++# Create a temporary old-style archive to link instead of a shared archive. ++old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds ++ ++# Commands used to build and install a shared archive. ++archive_cmds=$lt_archive_cmds ++archive_expsym_cmds=$lt_archive_expsym_cmds ++postinstall_cmds=$lt_postinstall_cmds ++postuninstall_cmds=$lt_postuninstall_cmds ++ ++# Commands to strip libraries. ++old_striplib=$lt_old_striplib ++striplib=$lt_striplib ++ ++# Method to check whether dependent libraries are shared objects. ++deplibs_check_method=$lt_deplibs_check_method ++ ++# Command to use when deplibs_check_method == file_magic. ++file_magic_cmd=$lt_file_magic_cmd ++ ++# Flag that allows shared libraries with undefined symbols to be built. ++allow_undefined_flag=$lt_allow_undefined_flag ++ ++# Flag that forces no undefined symbols. ++no_undefined_flag=$lt_no_undefined_flag ++ ++# Commands used to finish a libtool library installation in a directory. ++finish_cmds=$lt_finish_cmds ++ ++# Same as above, but a single script fragment to be evaled but not shown. ++finish_eval=$lt_finish_eval ++ ++# Take the output of nm and produce a listing of raw symbols and C names. ++global_symbol_pipe=$lt_global_symbol_pipe ++ ++# Transform the output of nm in a proper C declaration ++global_symbol_to_cdecl=$lt_global_symbol_to_cdecl ++ ++# Transform the output of nm in a C name address pair ++global_symbol_to_c_name_address=$lt_global_symbol_to_c_name_address ++ ++# This is the shared library runtime path variable. ++runpath_var=$runpath_var ++ ++# This is the shared library path variable. ++shlibpath_var=$shlibpath_var ++ ++# Is shlibpath searched before the hard-coded library search path? ++shlibpath_overrides_runpath=$shlibpath_overrides_runpath ++ ++# How to hardcode a shared library path into an executable. ++hardcode_action=$hardcode_action ++ ++# Whether we should hardcode library paths into libraries. ++hardcode_into_libs=$hardcode_into_libs ++ ++# Flag to hardcode \$libdir into a binary during linking. ++# This must work even if \$libdir does not exist. ++hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec ++ ++# Whether we need a single -rpath flag with a separated argument. ++hardcode_libdir_separator=$lt_hardcode_libdir_separator ++ ++# Set to yes if using DIR/libNAME.so during linking hardcodes DIR into the ++# resulting binary. ++hardcode_direct=$hardcode_direct ++ ++# Set to yes if using the -LDIR flag during linking hardcodes DIR into the ++# resulting binary. ++hardcode_minus_L=$hardcode_minus_L ++ ++# Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into ++# the resulting binary. ++hardcode_shlibpath_var=$hardcode_shlibpath_var ++ ++# Variables whose values should be saved in libtool wrapper scripts and ++# restored at relink time. ++variables_saved_for_relink="$variables_saved_for_relink" ++ ++# Whether libtool must link a program against all its dependency libraries. ++link_all_deplibs=$link_all_deplibs ++ ++# Compile-time system search path for libraries ++sys_lib_search_path_spec=$lt_sys_lib_search_path_spec ++ ++# Run-time system search path for libraries ++sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec ++ ++# Fix the shell variable \$srcfile for the compiler. ++fix_srcfile_path="$fix_srcfile_path" ++ ++# Set to yes if exported symbols are required. ++always_export_symbols=$always_export_symbols ++ ++# The commands to list exported symbols. ++export_symbols_cmds=$lt_export_symbols_cmds ++ ++# The commands to extract the exported symbol list from a shared archive. ++extract_expsyms_cmds=$lt_extract_expsyms_cmds ++ ++# Symbols that should not be listed in the preloaded symbols. ++exclude_expsyms=$lt_exclude_expsyms ++ ++# Symbols that must always be exported. ++include_expsyms=$lt_include_expsyms ++ ++# ### END LIBTOOL CONFIG ++ ++__EOF__ ++ ++ case $host_os in ++ aix3*) ++ cat <<\EOF >> "${ofile}T" ++ ++# AIX sometimes has problems with the GCC collect2 program. For some ++# reason, if we set the COLLECT_NAMES environment variable, the problems ++# vanish in a puff of smoke. ++if test "X${COLLECT_NAMES+set}" != Xset; then ++ COLLECT_NAMES= ++ export COLLECT_NAMES ++fi ++EOF ++ ;; ++ esac ++ ++ case $host_os in ++ cygwin* | mingw* | pw32* | os2*) ++ cat <<'EOF' >> "${ofile}T" ++ # This is a source program that is used to create dlls on Windows ++ # Don't remove nor modify the starting and closing comments ++# /* ltdll.c starts here */ ++# #define WIN32_LEAN_AND_MEAN ++# #include ++# #undef WIN32_LEAN_AND_MEAN ++# #include ++# ++# #ifndef __CYGWIN__ ++# # ifdef __CYGWIN32__ ++# # define __CYGWIN__ __CYGWIN32__ ++# # endif ++# #endif ++# ++# #ifdef __cplusplus ++# extern "C" { ++# #endif ++# BOOL APIENTRY DllMain (HINSTANCE hInst, DWORD reason, LPVOID reserved); ++# #ifdef __cplusplus ++# } ++# #endif ++# ++# #ifdef __CYGWIN__ ++# #include ++# DECLARE_CYGWIN_DLL( DllMain ); ++# #endif ++# HINSTANCE __hDllInstance_base; ++# ++# BOOL APIENTRY ++# DllMain (HINSTANCE hInst, DWORD reason, LPVOID reserved) ++# { ++# __hDllInstance_base = hInst; ++# return TRUE; ++# } ++# /* ltdll.c ends here */ ++ # This is a source program that is used to create import libraries ++ # on Windows for dlls which lack them. Don't remove nor modify the ++ # starting and closing comments ++# /* impgen.c starts here */ ++# /* Copyright (C) 1999-2000 Free Software Foundation, Inc. ++# ++# This file is part of GNU libtool. ++# ++# This program is free software; you can redistribute it and/or modify ++# it under the terms of the GNU General Public License as published by ++# the Free Software Foundation; either version 2 of the License, or ++# (at your option) any later version. ++# ++# This program is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++# GNU General Public License for more details. ++# ++# You should have received a copy of the GNU General Public License ++# along with this program; if not, write to the Free Software ++# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. ++# */ ++# ++# #include /* for printf() */ ++# #include /* for open(), lseek(), read() */ ++# #include /* for O_RDONLY, O_BINARY */ ++# #include /* for strdup() */ ++# ++# /* O_BINARY isn't required (or even defined sometimes) under Unix */ ++# #ifndef O_BINARY ++# #define O_BINARY 0 ++# #endif ++# ++# static unsigned int ++# pe_get16 (fd, offset) ++# int fd; ++# int offset; ++# { ++# unsigned char b[2]; ++# lseek (fd, offset, SEEK_SET); ++# read (fd, b, 2); ++# return b[0] + (b[1]<<8); ++# } ++# ++# static unsigned int ++# pe_get32 (fd, offset) ++# int fd; ++# int offset; ++# { ++# unsigned char b[4]; ++# lseek (fd, offset, SEEK_SET); ++# read (fd, b, 4); ++# return b[0] + (b[1]<<8) + (b[2]<<16) + (b[3]<<24); ++# } ++# ++# static unsigned int ++# pe_as32 (ptr) ++# void *ptr; ++# { ++# unsigned char *b = ptr; ++# return b[0] + (b[1]<<8) + (b[2]<<16) + (b[3]<<24); ++# } ++# ++# int ++# main (argc, argv) ++# int argc; ++# char *argv[]; ++# { ++# int dll; ++# unsigned long pe_header_offset, opthdr_ofs, num_entries, i; ++# unsigned long export_rva, export_size, nsections, secptr, expptr; ++# unsigned long name_rvas, nexp; ++# unsigned char *expdata, *erva; ++# char *filename, *dll_name; ++# ++# filename = argv[1]; ++# ++# dll = open(filename, O_RDONLY|O_BINARY); ++# if (dll < 1) ++# return 1; ++# ++# dll_name = filename; ++# ++# for (i=0; filename[i]; i++) ++# if (filename[i] == '/' || filename[i] == '\\' || filename[i] == ':') ++# dll_name = filename + i +1; ++# ++# pe_header_offset = pe_get32 (dll, 0x3c); ++# opthdr_ofs = pe_header_offset + 4 + 20; ++# num_entries = pe_get32 (dll, opthdr_ofs + 92); ++# ++# if (num_entries < 1) /* no exports */ ++# return 1; ++# ++# export_rva = pe_get32 (dll, opthdr_ofs + 96); ++# export_size = pe_get32 (dll, opthdr_ofs + 100); ++# nsections = pe_get16 (dll, pe_header_offset + 4 +2); ++# secptr = (pe_header_offset + 4 + 20 + ++# pe_get16 (dll, pe_header_offset + 4 + 16)); ++# ++# expptr = 0; ++# for (i = 0; i < nsections; i++) ++# { ++# char sname[8]; ++# unsigned long secptr1 = secptr + 40 * i; ++# unsigned long vaddr = pe_get32 (dll, secptr1 + 12); ++# unsigned long vsize = pe_get32 (dll, secptr1 + 16); ++# unsigned long fptr = pe_get32 (dll, secptr1 + 20); ++# lseek(dll, secptr1, SEEK_SET); ++# read(dll, sname, 8); ++# if (vaddr <= export_rva && vaddr+vsize > export_rva) ++# { ++# expptr = fptr + (export_rva - vaddr); ++# if (export_rva + export_size > vaddr + vsize) ++# export_size = vsize - (export_rva - vaddr); ++# break; ++# } ++# } ++# ++# expdata = (unsigned char*)malloc(export_size); ++# lseek (dll, expptr, SEEK_SET); ++# read (dll, expdata, export_size); ++# erva = expdata - export_rva; ++# ++# nexp = pe_as32 (expdata+24); ++# name_rvas = pe_as32 (expdata+32); ++# ++# printf ("EXPORTS\n"); ++# for (i = 0; i> "${ofile}T" || (rm -f "${ofile}T"; exit 1) ++ ++ mv -f "${ofile}T" "$ofile" || \ ++ (rm -f "$ofile" && cp "${ofile}T" "$ofile" && rm -f "${ofile}T") ++ chmod +x "$ofile" ++fi ++ ++ ++ ++ ++ ++# This can be used to rebuild libtool when needed ++LIBTOOL_DEPS="$ac_aux_dir/ltmain.sh" ++ ++# Always use our own libtool. ++LIBTOOL='$(SHELL) $(top_builddir)/libtool' ++ ++# Prevent multiple expansion ++ ++ ++ ++ ++# Check whether --with-target-subdir or --without-target-subdir was given. ++if test "${with_target_subdir+set}" = set; then ++ withval="$with_target_subdir" ++ ++fi; ++ ++# Check whether --with-cross-host or --without-cross-host was given. ++if test "${with_cross_host+set}" = set; then ++ withval="$with_cross_host" ++ ++fi; ++ ++echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5 ++echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6 ++ # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given. ++if test "${enable_maintainer_mode+set}" = set; then ++ enableval="$enable_maintainer_mode" ++ USE_MAINTAINER_MODE=$enableval ++else ++ USE_MAINTAINER_MODE=no ++fi; ++ echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5 ++echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6 ++ ++ ++if test $USE_MAINTAINER_MODE = yes; then ++ MAINTAINER_MODE_TRUE= ++ MAINTAINER_MODE_FALSE='#' ++else ++ MAINTAINER_MODE_TRUE='#' ++ MAINTAINER_MODE_FALSE= ++fi ++ ++ MAINT=$MAINTAINER_MODE_TRUE ++ ++ ++# automake wants to see AC_EXEEXT. But we don't need it. And having ++# it is actually a problem, because the compiler we're passed can't ++# necessarily do a full link. So we fool automake here. ++if false; then ++ # autoconf 2.50 runs AC_EXEEXT by default, and the macro expands ++ # to nothing, so nothing would remain between `then' and `fi' if it ++ # were not for the `:' below. ++ : ++ ++fi ++ ++echo "$as_me:$LINENO: checking for thread model used by GCC" >&5 ++echo $ECHO_N "checking for thread model used by GCC... $ECHO_C" >&6 ++THREADS=`$CC -v 2>&1 | sed -n 's/^Thread model: //p'` ++if test -z "$THREADS"; then ++ THREADS=no ++fi ++echo "$as_me:$LINENO: result: $THREADS" >&5 ++echo "${ECHO_T}$THREADS" >&6 ++ ++# Check whether --enable-parallel-mark or --disable-parallel-mark was given. ++if test "${enable_parallel_mark+set}" = set; then ++ enableval="$enable_parallel_mark" ++ case "$THREADS" in ++ no | none | single) ++ { { echo "$as_me:$LINENO: error: Parallel mark requires --enable-threads=x spec" >&5 ++echo "$as_me: error: Parallel mark requires --enable-threads=x spec" >&2;} ++ { (exit 1); exit 1; }; } ++ ;; ++ esac ++ ++fi; ++ ++INCLUDES=-I${srcdir}/include ++THREADLIBS= ++case "$THREADS" in ++ no | none | single) ++ THREADS=none ++ ;; ++ posix | pthreads) ++ THREADS=posix ++ THREADLIBS=-lpthread ++ case "$host" in ++ x86-*-linux* | ia64-*-linux* | i586-*-linux* | i686-*-linux* | x86_64-*-linux* ) ++ cat >>confdefs.h <<\_ACEOF ++@%:@define GC_LINUX_THREADS 1 ++_ACEOF ++ ++ cat >>confdefs.h <<\_ACEOF ++@%:@define _REENTRANT 1 ++_ACEOF ++ ++ if test "${enable_parallel_mark}"; then ++ cat >>confdefs.h <<\_ACEOF ++@%:@define PARALLEL_MARK 1 ++_ACEOF ++ ++ fi ++ cat >>confdefs.h <<\_ACEOF ++@%:@define THREAD_LOCAL_ALLOC 1 ++_ACEOF ++ ++ ;; ++ *-*-linux*) ++ cat >>confdefs.h <<\_ACEOF ++@%:@define GC_LINUX_THREADS 1 ++_ACEOF ++ ++ cat >>confdefs.h <<\_ACEOF ++@%:@define _REENTRANT 1 ++_ACEOF ++ ++ ;; ++ *-*-hpux*) ++ { echo "$as_me:$LINENO: WARNING: \"Only HP/UX 11 threads are supported.\"" >&5 ++echo "$as_me: WARNING: \"Only HP/UX 11 threads are supported.\"" >&2;} ++ cat >>confdefs.h <<\_ACEOF ++@%:@define GC_HPUX_THREADS 1 ++_ACEOF ++ ++ cat >>confdefs.h <<\_ACEOF ++@%:@define _POSIX_C_SOURCE 199506L ++_ACEOF ++ ++ if test "${enable_parallel_mark}" = yes; then ++ cat >>confdefs.h <<\_ACEOF ++@%:@define PARALLEL_MARK 1 ++_ACEOF ++ ++ fi ++ cat >>confdefs.h <<\_ACEOF ++@%:@define THREAD_LOCAL_ALLOC 1 ++_ACEOF ++ ++ THREADLIBS="-lpthread -lrt" ++ ;; ++ *-*-freebsd*) ++ { echo "$as_me:$LINENO: WARNING: \"FreeBSD does not yet fully support threads with Boehm GC.\"" >&5 ++echo "$as_me: WARNING: \"FreeBSD does not yet fully support threads with Boehm GC.\"" >&2;} ++ cat >>confdefs.h <<\_ACEOF ++@%:@define GC_FREEBSD_THREADS 1 ++_ACEOF ++ ++ INCLUDES="$INCLUDES -pthread" ++ THREADLIBS=-pthread ++ ;; ++ *-*-solaris*) ++ cat >>confdefs.h <<\_ACEOF ++@%:@define GC_SOLARIS_THREADS 1 ++_ACEOF ++ ++ cat >>confdefs.h <<\_ACEOF ++@%:@define GC_SOLARIS_PTHREADS 1 ++_ACEOF ++ ++ ;; ++ *-*-irix*) ++ cat >>confdefs.h <<\_ACEOF ++@%:@define GC_IRIX_THREADS 1 ++_ACEOF ++ ++ ;; ++ *-*-cygwin*) ++ THREADLIBS= ++ ;; ++ *-*-darwin*) ++ cat >>confdefs.h <<\_ACEOF ++@%:@define GC_DARWIN_THREADS 1 ++_ACEOF ++ ++ cat >>confdefs.h <<\_ACEOF ++@%:@define THREAD_LOCAL_ALLOC 1 ++_ACEOF ++ ++ if test "${enable_parallel_mark}" = yes; then ++ cat >>confdefs.h <<\_ACEOF ++@%:@define PARALLEL_MARK 1 ++_ACEOF ++ ++ fi ++ ;; ++ esac ++ ;; ++ win32) ++ cat >>confdefs.h <<\_ACEOF ++@%:@define GC_WIN32_THREADS 1 ++_ACEOF ++ ++ cat >>confdefs.h <<\_ACEOF ++@%:@define NO_GETENV 1 ++_ACEOF ++ ++ ;; ++ decosf1 | irix | mach | os2 | solaris | dce | vxworks) ++ { { echo "$as_me:$LINENO: error: thread package $THREADS not yet supported" >&5 ++echo "$as_me: error: thread package $THREADS not yet supported" >&2;} ++ { (exit 1); exit 1; }; } ++ ;; ++ *) ++ { { echo "$as_me:$LINENO: error: $THREADS is an unknown thread package" >&5 ++echo "$as_me: error: $THREADS is an unknown thread package" >&2;} ++ { (exit 1); exit 1; }; } ++ ;; ++esac ++ ++ ++case "$host" in ++ powerpc-*-darwin*) ++ powerpc_darwin=true ++ ;; ++esac ++ ++ ++if test x$powerpc_darwin = xtrue; then ++ POWERPC_DARWIN_TRUE= ++ POWERPC_DARWIN_FALSE='#' ++else ++ POWERPC_DARWIN_TRUE='#' ++ POWERPC_DARWIN_FALSE= ++fi ++ ++ ++# We never want libdl on darwin. It is a fake libdl that just ends up making ++# dyld calls anyway ++case "$host" in ++ *-*-darwin*) ;; ++ *) ++ echo "$as_me:$LINENO: checking for dlopen in -ldl" >&5 ++echo $ECHO_N "checking for dlopen in -ldl... $ECHO_C" >&6 ++if test "${ac_cv_lib_dl_dlopen+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ ac_check_lib_save_LIBS=$LIBS ++LIBS="-ldl $LIBS" ++cat >conftest.$ac_ext <<_ACEOF ++#line $LINENO "configure" ++#include "confdefs.h" ++ ++/* Override any gcc2 internal prototype to avoid an error. */ ++#ifdef __cplusplus ++extern "C" ++#endif ++/* We use char because int might match the return type of a gcc2 ++ builtin and then its argument prototype would still apply. */ ++char dlopen (); ++int ++main () ++{ ++dlopen (); ++ ; ++ return 0; ++} ++_ACEOF ++rm -f conftest.$ac_objext conftest$ac_exeext ++if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 ++ (eval $ac_link) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && ++ { ac_try='test -s conftest$ac_exeext' ++ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 ++ (eval $ac_try) 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ ac_cv_lib_dl_dlopen=yes ++else ++ echo "$as_me: failed program was:" >&5 ++cat conftest.$ac_ext >&5 ++ac_cv_lib_dl_dlopen=no ++fi ++rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext ++LIBS=$ac_check_lib_save_LIBS ++fi ++echo "$as_me:$LINENO: result: $ac_cv_lib_dl_dlopen" >&5 ++echo "${ECHO_T}$ac_cv_lib_dl_dlopen" >&6 ++if test $ac_cv_lib_dl_dlopen = yes; then ++ EXTRA_TEST_LIBS="$EXTRA_TEST_LIBS -ldl" ++fi ++ ++ ;; ++esac ++ ++ ++ ++target_all=libgcjgc.la ++ ++ ++ ++TARGET_ECOS="no" ++ ++# Check whether --with-ecos or --without-ecos was given. ++if test "${with_ecos+set}" = set; then ++ withval="$with_ecos" ++ TARGET_ECOS="$with_ecos" ++ ++fi; ++ ++addobjs= ++CXXINCLUDES= ++case "$TARGET_ECOS" in ++ no) ++ ;; ++ *) ++ cat >>confdefs.h <<\_ACEOF ++@%:@define ECOS 1 ++_ACEOF ++ ++ CXXINCLUDES="-I${TARGET_ECOS}/include" ++ addobjs="$addobjs ecos.lo" ++ ;; ++esac ++ ++ ++ ++ ++ ++machdep= ++case "$host" in ++ alpha*-*-openbsd*) ++ machdep="alpha_mach_dep.lo" ++ if test x"${ac_cv_lib_dl_dlopen}" != xyes ; then ++ { echo "$as_me:$LINENO: WARNING: OpenBSD/Alpha without dlopen(). Shared library support is disabled" >&5 ++echo "$as_me: WARNING: OpenBSD/Alpha without dlopen(). Shared library support is disabled" >&2;} ++ # Check whether --enable-shared or --disable-shared was given. ++if test "${enable_shared+set}" = set; then ++ enableval="$enable_shared" ++ p=${PACKAGE-default} ++case $enableval in ++yes) enable_shared=yes ;; ++no) enable_shared=no ;; ++*) ++ enable_shared=no ++ # Look at the argument we got. We use all the common list separators. ++ IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:," ++ for pkg in $enableval; do ++ if test "X$pkg" = "X$p"; then ++ enable_shared=yes ++ fi ++ done ++ IFS="$ac_save_ifs" ++ ;; ++esac ++else ++ enable_shared=no ++fi; ++ fi ++ ;; ++ alpha*-*-*) ++ machdep="alpha_mach_dep.lo" ++ ;; ++ i?86-*-solaris2.[89]*) ++ cat >>confdefs.h <<\_ACEOF ++@%:@define SOLARIS25_PROC_VDB_BUG_FIXED 1 ++_ACEOF ++ ++ ;; ++ mipstx39-*-elf*) ++ machdep="mips_ultrix_mach_dep.lo" ++ cat >>confdefs.h <<\_ACEOF ++@%:@define STACKBASE __stackbase ++_ACEOF ++ ++ cat >>confdefs.h <<\_ACEOF ++@%:@define DATASTART_IS_ETEXT 1 ++_ACEOF ++ ++ ;; ++ mips-dec-ultrix*) ++ machdep="mips_ultrix_mach-dep.lo" ++ ;; ++ mips*-*-linux*) ++ ;; ++ mips-*-*) ++ machdep="mips_sgi_mach_dep.lo" ++ cat >>confdefs.h <<\_ACEOF ++@%:@define NO_EXECUTE_PERMISSION 1 ++_ACEOF ++ ++ ;; ++ sparc-sun-solaris2.3*) ++ machdep="sparc_mach_dep.lo" ++ cat >>confdefs.h <<\_ACEOF ++@%:@define SUNOS53_SHARED_LIB 1 ++_ACEOF ++ ++ ;; ++ sparc-sun-solaris2.*) ++ machdep="sparc_mach_dep.lo" ++ ;; ++ ia64-*-*) ++ machdep="mach_dep.lo ia64_save_regs_in_stack.lo" ++ ;; ++esac ++if test x"$machdep" = x; then ++ machdep="mach_dep.lo" ++fi ++addobjs="$addobjs $machdep" ++ ++ ++case "$host" in ++ sparc-sun-solaris2*) ++ if test "$GCC" = yes; then ++ new_CFLAGS= ++ for i in $CFLAGS; do ++ case "$i" in ++ -O*) ++ ;; ++ *) ++ new_CFLAGS="$new_CFLAGS $i" ++ ;; ++ esac ++ done ++ CFLAGS="$new_CFLAGS" ++ fi ++ ;; ++esac ++ ++MY_CFLAGS="$CFLAGS" ++ ++ ++cat >>confdefs.h <<\_ACEOF ++@%:@define SILENT 1 ++_ACEOF ++ ++cat >>confdefs.h <<\_ACEOF ++@%:@define NO_SIGNALS 1 ++_ACEOF ++ ++cat >>confdefs.h <<\_ACEOF ++@%:@define NO_EXECUTE_PERMISSION 1 ++_ACEOF ++ ++cat >>confdefs.h <<\_ACEOF ++@%:@define ALL_INTERIOR_POINTERS 1 ++_ACEOF ++ ++ ++cat >>confdefs.h <<\_ACEOF ++@%:@define JAVA_FINALIZATION 1 ++_ACEOF ++ ++cat >>confdefs.h <<\_ACEOF ++@%:@define GC_GCJ_SUPPORT 1 ++_ACEOF ++ ++cat >>confdefs.h <<\_ACEOF ++@%:@define ATOMIC_UNCOLLECTABLE 1 ++_ACEOF ++ ++ ++if test -n "${with_cross_host}"; then ++ cat >>confdefs.h <<\_ACEOF ++@%:@define NO_SIGSET 1 ++_ACEOF ++ ++ cat >>confdefs.h <<\_ACEOF ++@%:@define NO_DEBUGGING 1 ++_ACEOF ++ ++fi ++ ++# Check whether --enable-full-debug or --disable-full-debug was given. ++if test "${enable_full_debug+set}" = set; then ++ enableval="$enable_full_debug" ++ if test "$enable_full_debug" = "yes"; then ++ { echo "$as_me:$LINENO: WARNING: \"Must define GC_DEBUG and use debug alloc. in clients.\"" >&5 ++echo "$as_me: WARNING: \"Must define GC_DEBUG and use debug alloc. in clients.\"" >&2;} ++ cat >>confdefs.h <<\_ACEOF ++@%:@define KEEP_BACK_PTRS 1 ++_ACEOF ++ ++ cat >>confdefs.h <<\_ACEOF ++@%:@define DBG_HDRS_ALL 1 ++_ACEOF ++ ++ case $host in ++ ia64-*-linux* ) ++ cat >>confdefs.h <<\_ACEOF ++@%:@define MAKE_BACK_GRAPH 1 ++_ACEOF ++ ++ ;; ++ x86-*-linux* | i586-*-linux* | i686-*-linux* | x86_64-*-linux* ) ++ cat >>confdefs.h <<\_ACEOF ++@%:@define MAKE_BACK_GRAPH 1 ++_ACEOF ++ ++ { echo "$as_me:$LINENO: WARNING: \"Client must not use -fomit-frame-pointer.\"" >&5 ++echo "$as_me: WARNING: \"Client must not use -fomit-frame-pointer.\"" >&2;} ++ cat >>confdefs.h <<\_ACEOF ++@%:@define SAVE_CALL_COUNT 8 ++_ACEOF ++ ++ ;; ++ esac ++ fi ++fi; ++ ++ ++ ++if test -z "$with_cross_host"; then ++ USE_LIBDIR_TRUE= ++ USE_LIBDIR_FALSE='#' ++else ++ USE_LIBDIR_TRUE='#' ++ USE_LIBDIR_FALSE= ++fi ++ ++ ++if test "${multilib}" = "yes"; then ++ multilib_arg="--enable-multilib" ++else ++ multilib_arg= ++fi ++ ++ ac_config_files="$ac_config_files Makefile include/Makefile" ++ ac_config_commands="$ac_config_commands default" ++cat >confcache <<\_ACEOF ++# This file is a shell script that caches the results of configure ++# tests run on this system so they can be shared between configure ++# scripts and configure runs, see configure's option --config-cache. ++# It is not useful on other systems. If it contains results you don't ++# want to keep, you may remove or edit it. ++# ++# config.status only pays attention to the cache file if you give it ++# the --recheck option to rerun configure. ++# ++# `ac_cv_env_foo' variables (set or unset) will be overridden when ++# loading this file, other *unset* `ac_cv_foo' will be assigned the ++# following values. ++ ++_ACEOF ++ ++# The following way of writing the cache mishandles newlines in values, ++# but we know of no workaround that is simple, portable, and efficient. ++# So, don't put newlines in cache variables' values. ++# Ultrix sh set writes to stderr and can't be redirected directly, ++# and sets the high bit in the cache file unless we assign to the vars. ++{ ++ (set) 2>&1 | ++ case `(ac_space=' '; set | grep ac_space) 2>&1` in ++ *ac_space=\ *) ++ # `set' does not quote correctly, so add quotes (double-quote ++ # substitution turns \\\\ into \\, and sed turns \\ into \). ++ sed -n \ ++ "s/'/'\\\\''/g; ++ s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" ++ ;; ++ *) ++ # `set' quotes correctly as required by POSIX, so do not add quotes. ++ sed -n \ ++ "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p" ++ ;; ++ esac; ++} | ++ sed ' ++ t clear ++ : clear ++ s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/ ++ t end ++ /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/ ++ : end' >>confcache ++if cmp -s $cache_file confcache; then :; else ++ if test -w $cache_file; then ++ test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file" ++ cat confcache >$cache_file ++ else ++ echo "not updating unwritable cache $cache_file" ++ fi ++fi ++rm -f confcache ++ ++test "x$prefix" = xNONE && prefix=$ac_default_prefix ++# Let make expand exec_prefix. ++test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' ++ ++# VPATH may cause trouble with some makes, so we remove $(srcdir), ++# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and ++# trailing colons and then remove the whole line if VPATH becomes empty ++# (actually we leave an empty line to preserve line numbers). ++if test "x$srcdir" = x.; then ++ ac_vpsub='/^[ ]*VPATH[ ]*=/{ ++s/:*\$(srcdir):*/:/; ++s/:*\${srcdir}:*/:/; ++s/:*@srcdir@:*/:/; ++s/^\([^=]*=[ ]*\):*/\1/; ++s/:*$//; ++s/^[^=]*=[ ]*$//; ++}' ++fi ++ ++# Transform confdefs.h into DEFS. ++# Protect against shell expansion while executing Makefile rules. ++# Protect against Makefile macro expansion. ++# ++# If the first sed substitution is executed (which looks for macros that ++# take arguments), then we branch to the quote section. Otherwise, ++# look for a macro that doesn't take arguments. ++cat >confdef2opt.sed <<\_ACEOF ++t clear ++: clear ++s,^[ ]*#[ ]*define[ ][ ]*\([^ (][^ (]*([^)]*)\)[ ]*\(.*\),-D\1=\2,g ++t quote ++s,^[ ]*#[ ]*define[ ][ ]*\([^ ][^ ]*\)[ ]*\(.*\),-D\1=\2,g ++t quote ++d ++: quote ++s,[ `~#$^&*(){}\\|;'"<>?],\\&,g ++s,\[,\\&,g ++s,\],\\&,g ++s,\$,$$,g ++p ++_ACEOF ++# We use echo to avoid assuming a particular line-breaking character. ++# The extra dot is to prevent the shell from consuming trailing ++# line-breaks from the sub-command output. A line-break within ++# single-quotes doesn't work because, if this script is created in a ++# platform that uses two characters for line-breaks (e.g., DOS), tr ++# would break. ++ac_LF_and_DOT=`echo; echo .` ++DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'` ++rm -f confdef2opt.sed ++ ++ ++ac_libobjs= ++ac_ltlibobjs= ++for ac_i in : $LIB@&t@OBJS; do test "x$ac_i" = x: && continue ++ # 1. Remove the extension, and $U if already installed. ++ ac_i=`echo "$ac_i" | ++ sed 's/\$U\././;s/\.o$//;s/\.obj$//'` ++ # 2. Add them. ++ ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext" ++ ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo' ++done ++LIB@&t@OBJS=$ac_libobjs ++ ++LTLIBOBJS=$ac_ltlibobjs ++ ++ ++if test -z "${MAINTAINER_MODE_TRUE}" && test -z "${MAINTAINER_MODE_FALSE}"; then ++ { { echo "$as_me:$LINENO: error: conditional \"MAINTAINER_MODE\" was never defined. ++Usually this means the macro was only invoked conditionally." >&5 ++echo "$as_me: error: conditional \"MAINTAINER_MODE\" was never defined. ++Usually this means the macro was only invoked conditionally." >&2;} ++ { (exit 1); exit 1; }; } ++fi ++if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then ++ { { echo "$as_me:$LINENO: error: conditional \"AMDEP\" was never defined. ++Usually this means the macro was only invoked conditionally." >&5 ++echo "$as_me: error: conditional \"AMDEP\" was never defined. ++Usually this means the macro was only invoked conditionally." >&2;} ++ { (exit 1); exit 1; }; } ++fi ++if test -z "${MAINTAINER_MODE_TRUE}" && test -z "${MAINTAINER_MODE_FALSE}"; then ++ { { echo "$as_me:$LINENO: error: conditional \"MAINTAINER_MODE\" was never defined. ++Usually this means the macro was only invoked conditionally." >&5 ++echo "$as_me: error: conditional \"MAINTAINER_MODE\" was never defined. ++Usually this means the macro was only invoked conditionally." >&2;} ++ { (exit 1); exit 1; }; } ++fi ++if test -z "${POWERPC_DARWIN_TRUE}" && test -z "${POWERPC_DARWIN_FALSE}"; then ++ { { echo "$as_me:$LINENO: error: conditional \"POWERPC_DARWIN\" was never defined. ++Usually this means the macro was only invoked conditionally." >&5 ++echo "$as_me: error: conditional \"POWERPC_DARWIN\" was never defined. ++Usually this means the macro was only invoked conditionally." >&2;} ++ { (exit 1); exit 1; }; } ++fi ++if test -z "${USE_LIBDIR_TRUE}" && test -z "${USE_LIBDIR_FALSE}"; then ++ { { echo "$as_me:$LINENO: error: conditional \"USE_LIBDIR\" was never defined. ++Usually this means the macro was only invoked conditionally." >&5 ++echo "$as_me: error: conditional \"USE_LIBDIR\" was never defined. ++Usually this means the macro was only invoked conditionally." >&2;} ++ { (exit 1); exit 1; }; } ++fi ++ ++: ${CONFIG_STATUS=./config.status} ++ac_clean_files_save=$ac_clean_files ++ac_clean_files="$ac_clean_files $CONFIG_STATUS" ++{ echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5 ++echo "$as_me: creating $CONFIG_STATUS" >&6;} ++cat >$CONFIG_STATUS <<_ACEOF ++#! $SHELL ++# Generated by $as_me. ++# Run this file to recreate the current configuration. ++# Compiler output produced by configure, useful for debugging ++# configure, is in config.log if it exists. ++ ++debug=false ++SHELL=\${CONFIG_SHELL-$SHELL} ++_ACEOF ++ ++cat >>$CONFIG_STATUS <<\_ACEOF ++## --------------------- ## ++## M4sh Initialization. ## ++## --------------------- ## ++ ++# Be Bourne compatible ++if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then ++ emulate sh ++ NULLCMD=: ++ # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which ++ # is contrary to our usage. Disable this feature. ++ alias -g '${1+"$@"}'='"$@"' ++elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then ++ set -o posix ++fi ++ ++# Support unset when possible. ++if (FOO=FOO; unset FOO) >/dev/null 2>&1; then ++ as_unset=unset ++else ++ as_unset=false ++fi ++ ++ ++# Work around bugs in pre-3.0 UWIN ksh. ++$as_unset ENV MAIL MAILPATH ++PS1='$ ' ++PS2='> ' ++PS4='+ ' ++ ++# NLS nuisances. ++for as_var in LANG LANGUAGE LC_ALL LC_COLLATE LC_CTYPE LC_NUMERIC LC_MESSAGES LC_TIME ++do ++ if (set +x; test -n "`(eval $as_var=C; export $as_var) 2>&1`"); then ++ eval $as_var=C; export $as_var ++ else ++ $as_unset $as_var ++ fi ++done ++ ++# Required to use basename. ++if expr a : '\(a\)' >/dev/null 2>&1; then ++ as_expr=expr ++else ++ as_expr=false ++fi ++ ++if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then ++ as_basename=basename ++else ++ as_basename=false ++fi ++ ++ ++# Name of the executable. ++as_me=`$as_basename "$0" || ++$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ ++ X"$0" : 'X\(//\)$' \| \ ++ X"$0" : 'X\(/\)$' \| \ ++ . : '\(.\)' 2>/dev/null || ++echo X/"$0" | ++ sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; } ++ /^X\/\(\/\/\)$/{ s//\1/; q; } ++ /^X\/\(\/\).*/{ s//\1/; q; } ++ s/.*/./; q'` ++ ++ ++# PATH needs CR, and LINENO needs CR and PATH. ++# Avoid depending upon Character Ranges. ++as_cr_letters='abcdefghijklmnopqrstuvwxyz' ++as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' ++as_cr_Letters=$as_cr_letters$as_cr_LETTERS ++as_cr_digits='0123456789' ++as_cr_alnum=$as_cr_Letters$as_cr_digits ++ ++# The user is always right. ++if test "${PATH_SEPARATOR+set}" != set; then ++ echo "#! /bin/sh" >conftest.sh ++ echo "exit 0" >>conftest.sh ++ chmod +x conftest.sh ++ if (PATH="/nonexistent;."; conftest.sh) >/dev/null 2>&1; then ++ PATH_SEPARATOR=';' ++ else ++ PATH_SEPARATOR=: ++ fi ++ rm -f conftest.sh ++fi ++ ++ ++ as_lineno_1=$LINENO ++ as_lineno_2=$LINENO ++ as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null` ++ test "x$as_lineno_1" != "x$as_lineno_2" && ++ test "x$as_lineno_3" = "x$as_lineno_2" || { ++ # Find who we are. Look in the path if we contain no path at all ++ # relative or not. ++ case $0 in ++ *[\\/]* ) as_myself=$0 ;; ++ *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break ++done ++ ++ ;; ++ esac ++ # We did not find ourselves, most probably we were run as `sh COMMAND' ++ # in which case we are not to be found in the path. ++ if test "x$as_myself" = x; then ++ as_myself=$0 ++ fi ++ if test ! -f "$as_myself"; then ++ { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5 ++echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;} ++ { (exit 1); exit 1; }; } ++ fi ++ case $CONFIG_SHELL in ++ '') ++ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for as_base in sh bash ksh sh5; do ++ case $as_dir in ++ /*) ++ if ("$as_dir/$as_base" -c ' ++ as_lineno_1=$LINENO ++ as_lineno_2=$LINENO ++ as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null` ++ test "x$as_lineno_1" != "x$as_lineno_2" && ++ test "x$as_lineno_3" = "x$as_lineno_2" ') 2>/dev/null; then ++ $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; } ++ $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; } ++ CONFIG_SHELL=$as_dir/$as_base ++ export CONFIG_SHELL ++ exec "$CONFIG_SHELL" "$0" ${1+"$@"} ++ fi;; ++ esac ++ done ++done ++;; ++ esac ++ ++ # Create $as_me.lineno as a copy of $as_myself, but with $LINENO ++ # uniformly replaced by the line number. The first 'sed' inserts a ++ # line-number line before each line; the second 'sed' does the real ++ # work. The second script uses 'N' to pair each line-number line ++ # with the numbered line, and appends trailing '-' during ++ # substitution so that $LINENO is not a special case at line end. ++ # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the ++ # second 'sed' script. Blame Lee E. McMahon for sed's syntax. :-) ++ sed '=' <$as_myself | ++ sed ' ++ N ++ s,$,-, ++ : loop ++ s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3, ++ t loop ++ s,-$,, ++ s,^['$as_cr_digits']*\n,, ++ ' >$as_me.lineno && ++ chmod +x $as_me.lineno || ++ { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5 ++echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;} ++ { (exit 1); exit 1; }; } ++ ++ # Don't try to exec as it changes $[0], causing all sort of problems ++ # (the dirname of $[0] is not the place where we might find the ++ # original and so on. Autoconf is especially sensible to this). ++ . ./$as_me.lineno ++ # Exit status is that of the last command. ++ exit ++} ++ ++ ++case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in ++ *c*,-n*) ECHO_N= ECHO_C=' ++' ECHO_T=' ' ;; ++ *c*,* ) ECHO_N=-n ECHO_C= ECHO_T= ;; ++ *) ECHO_N= ECHO_C='\c' ECHO_T= ;; ++esac ++ ++if expr a : '\(a\)' >/dev/null 2>&1; then ++ as_expr=expr ++else ++ as_expr=false ++fi ++ ++rm -f conf$$ conf$$.exe conf$$.file ++echo >conf$$.file ++if ln -s conf$$.file conf$$ 2>/dev/null; then ++ # We could just check for DJGPP; but this test a) works b) is more generic ++ # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04). ++ if test -f conf$$.exe; then ++ # Don't use ln at all; we don't have any links ++ as_ln_s='cp -p' ++ else ++ as_ln_s='ln -s' ++ fi ++elif ln conf$$.file conf$$ 2>/dev/null; then ++ as_ln_s=ln ++else ++ as_ln_s='cp -p' ++fi ++rm -f conf$$ conf$$.exe conf$$.file ++ ++if mkdir -p . 2>/dev/null; then ++ as_mkdir_p=: ++else ++ as_mkdir_p=false ++fi ++ ++as_executable_p="test -f" ++ ++# Sed expression to map a string onto a valid CPP name. ++as_tr_cpp="sed y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g" ++ ++# Sed expression to map a string onto a valid variable name. ++as_tr_sh="sed y%*+%pp%;s%[^_$as_cr_alnum]%_%g" ++ ++ ++# IFS ++# We need space, tab and new line, in precisely that order. ++as_nl=' ++' ++IFS=" $as_nl" ++ ++# CDPATH. ++$as_unset CDPATH ++ ++exec 6>&1 ++ ++# Open the log real soon, to keep \$[0] and so on meaningful, and to ++# report actual input values of CONFIG_FILES etc. instead of their ++# values after options handling. Logging --version etc. is OK. ++exec 5>>config.log ++{ ++ echo ++ sed 'h;s/./-/g;s/^.../@%:@@%:@ /;s/...$/ @%:@@%:@/;p;x;p;x' <<_ASBOX ++@%:@@%:@ Running $as_me. @%:@@%:@ ++_ASBOX ++} >&5 ++cat >&5 <<_CSEOF ++ ++This file was extended by $as_me, which was ++generated by GNU Autoconf 2.54. Invocation command line was ++ ++ CONFIG_FILES = $CONFIG_FILES ++ CONFIG_HEADERS = $CONFIG_HEADERS ++ CONFIG_LINKS = $CONFIG_LINKS ++ CONFIG_COMMANDS = $CONFIG_COMMANDS ++ $ $0 $@ ++ ++_CSEOF ++echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5 ++echo >&5 ++_ACEOF ++ ++# Files that config.status was made for. ++if test -n "$ac_config_files"; then ++ echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS ++fi ++ ++if test -n "$ac_config_headers"; then ++ echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS ++fi ++ ++if test -n "$ac_config_links"; then ++ echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS ++fi ++ ++if test -n "$ac_config_commands"; then ++ echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS ++fi ++ ++cat >>$CONFIG_STATUS <<\_ACEOF ++ ++ac_cs_usage="\ ++\`$as_me' instantiates files from templates according to the ++current configuration. ++ ++Usage: $0 [OPTIONS] [FILE]... ++ ++ -h, --help print this help, then exit ++ -V, --version print version number, then exit ++ -d, --debug don't remove temporary files ++ --recheck update $as_me by reconfiguring in the same conditions ++ --file=FILE[:TEMPLATE] ++ instantiate the configuration file FILE ++ ++Configuration files: ++$config_files ++ ++Configuration commands: ++$config_commands ++ ++Report bugs to ." ++_ACEOF ++ ++cat >>$CONFIG_STATUS <<_ACEOF ++ac_cs_version="\\ ++config.status ++configured by $0, generated by GNU Autoconf 2.54, ++ with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\" ++ ++Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001 ++Free Software Foundation, Inc. ++This config.status script is free software; the Free Software Foundation ++gives unlimited permission to copy, distribute and modify it." ++srcdir=$srcdir ++INSTALL="$INSTALL" ++_ACEOF ++ ++cat >>$CONFIG_STATUS <<\_ACEOF ++# If no file are specified by the user, then we need to provide default ++# value. By we need to know if files were specified by the user. ++ac_need_defaults=: ++while test $# != 0 ++do ++ case $1 in ++ --*=*) ++ ac_option=`expr "x$1" : 'x\([^=]*\)='` ++ ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'` ++ ac_shift=: ++ ;; ++ -*) ++ ac_option=$1 ++ ac_optarg=$2 ++ ac_shift=shift ++ ;; ++ *) # This is not an option, so the user has probably given explicit ++ # arguments. ++ ac_option=$1 ++ ac_need_defaults=false;; ++ esac ++ ++ case $ac_option in ++ # Handling of the options. ++_ACEOF ++cat >>$CONFIG_STATUS <<_ACEOF ++ -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) ++ echo "running $SHELL $0 " $ac_configure_args " --no-create --no-recursion" ++ exec $SHELL $0 $ac_configure_args --no-create --no-recursion ;; ++_ACEOF ++cat >>$CONFIG_STATUS <<\_ACEOF ++ --version | --vers* | -V ) ++ echo "$ac_cs_version"; exit 0 ;; ++ --he | --h) ++ # Conflict between --help and --header ++ { { echo "$as_me:$LINENO: error: ambiguous option: $1 ++Try \`$0 --help' for more information." >&5 ++echo "$as_me: error: ambiguous option: $1 ++Try \`$0 --help' for more information." >&2;} ++ { (exit 1); exit 1; }; };; ++ --help | --hel | -h ) ++ echo "$ac_cs_usage"; exit 0 ;; ++ --debug | --d* | -d ) ++ debug=: ;; ++ --file | --fil | --fi | --f ) ++ $ac_shift ++ CONFIG_FILES="$CONFIG_FILES $ac_optarg" ++ ac_need_defaults=false;; ++ --header | --heade | --head | --hea ) ++ $ac_shift ++ CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg" ++ ac_need_defaults=false;; ++ ++ # This is an error. ++ -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1 ++Try \`$0 --help' for more information." >&5 ++echo "$as_me: error: unrecognized option: $1 ++Try \`$0 --help' for more information." >&2;} ++ { (exit 1); exit 1; }; } ;; ++ ++ *) ac_config_targets="$ac_config_targets $1" ;; ++ ++ esac ++ shift ++done ++ ++_ACEOF ++ ++cat >>$CONFIG_STATUS <<_ACEOF ++# ++# INIT-COMMANDS section. ++# ++ ++AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir" ++srcdir=${srcdir} ++host=${host} ++target=${target} ++with_multisubdir=${with_multisubdir} ++ac_configure_args="${multilib_arg} ${ac_configure_args}" ++CONFIG_SHELL=${CONFIG_SHELL-/bin/sh} ++gc_basedir=${gc_basedir} ++CC="${CC}" ++DEFS="$DEFS" ++ ++ ++_ACEOF ++ ++ ++ ++cat >>$CONFIG_STATUS <<\_ACEOF ++for ac_config_target in $ac_config_targets ++do ++ case "$ac_config_target" in ++ # Handling of arguments. ++ "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;; ++ "include/Makefile" ) CONFIG_FILES="$CONFIG_FILES include/Makefile" ;; ++ "depfiles" ) CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;; ++ "default" ) CONFIG_COMMANDS="$CONFIG_COMMANDS default" ;; ++ *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5 ++echo "$as_me: error: invalid argument: $ac_config_target" >&2;} ++ { (exit 1); exit 1; }; };; ++ esac ++done ++ ++# If the user did not use the arguments to specify the items to instantiate, ++# then the envvar interface is used. Set only those that are not. ++# We use the long form for the default assignment because of an extremely ++# bizarre bug on SunOS 4.1.3. ++if $ac_need_defaults; then ++ test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files ++ test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands ++fi ++ ++# Create a temporary directory, and hook for its removal unless debugging. ++$debug || ++{ ++ trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0 ++ trap '{ (exit 1); exit 1; }' 1 2 13 15 ++} ++ ++# Create a (secure) tmp directory for tmp files. ++: ${TMPDIR=/tmp} ++{ ++ tmp=`(umask 077 && mktemp -d -q "$TMPDIR/csXXXXXX") 2>/dev/null` && ++ test -n "$tmp" && test -d "$tmp" ++} || ++{ ++ tmp=$TMPDIR/cs$$-$RANDOM ++ (umask 077 && mkdir $tmp) ++} || ++{ ++ echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ++ { (exit 1); exit 1; } ++} ++ ++_ACEOF ++ ++cat >>$CONFIG_STATUS <<_ACEOF ++ ++# ++# CONFIG_FILES section. ++# ++ ++# No need to generate the scripts if there are no CONFIG_FILES. ++# This happens for instance when ./config.status config.h ++if test -n "\$CONFIG_FILES"; then ++ # Protect against being on the right side of a sed subst in config.status. ++ sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g; ++ s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF ++s,@SHELL@,$SHELL,;t t ++s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t ++s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t ++s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t ++s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t ++s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t ++s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t ++s,@exec_prefix@,$exec_prefix,;t t ++s,@prefix@,$prefix,;t t ++s,@program_transform_name@,$program_transform_name,;t t ++s,@bindir@,$bindir,;t t ++s,@sbindir@,$sbindir,;t t ++s,@libexecdir@,$libexecdir,;t t ++s,@datadir@,$datadir,;t t ++s,@sysconfdir@,$sysconfdir,;t t ++s,@sharedstatedir@,$sharedstatedir,;t t ++s,@localstatedir@,$localstatedir,;t t ++s,@libdir@,$libdir,;t t ++s,@includedir@,$includedir,;t t ++s,@oldincludedir@,$oldincludedir,;t t ++s,@infodir@,$infodir,;t t ++s,@mandir@,$mandir,;t t ++s,@build_alias@,$build_alias,;t t ++s,@host_alias@,$host_alias,;t t ++s,@target_alias@,$target_alias,;t t ++s,@DEFS@,$DEFS,;t t ++s,@ECHO_C@,$ECHO_C,;t t ++s,@ECHO_N@,$ECHO_N,;t t ++s,@ECHO_T@,$ECHO_T,;t t ++s,@LIBS@,$LIBS,;t t ++s,@gc_basedir@,$gc_basedir,;t t ++s,@build@,$build,;t t ++s,@build_cpu@,$build_cpu,;t t ++s,@build_vendor@,$build_vendor,;t t ++s,@build_os@,$build_os,;t t ++s,@host@,$host,;t t ++s,@host_cpu@,$host_cpu,;t t ++s,@host_vendor@,$host_vendor,;t t ++s,@host_os@,$host_os,;t t ++s,@target@,$target,;t t ++s,@target_cpu@,$target_cpu,;t t ++s,@target_vendor@,$target_vendor,;t t ++s,@target_os@,$target_os,;t t ++s,@mkinstalldirs@,$mkinstalldirs,;t t ++s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t ++s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t ++s,@INSTALL_DATA@,$INSTALL_DATA,;t t ++s,@PACKAGE@,$PACKAGE,;t t ++s,@VERSION@,$VERSION,;t t ++s,@ACLOCAL@,$ACLOCAL,;t t ++s,@AUTOCONF@,$AUTOCONF,;t t ++s,@AUTOMAKE@,$AUTOMAKE,;t t ++s,@AUTOHEADER@,$AUTOHEADER,;t t ++s,@MAKEINFO@,$MAKEINFO,;t t ++s,@AMTAR@,$AMTAR,;t t ++s,@install_sh@,$install_sh,;t t ++s,@STRIP@,$STRIP,;t t ++s,@ac_ct_STRIP@,$ac_ct_STRIP,;t t ++s,@INSTALL_STRIP_PROGRAM@,$INSTALL_STRIP_PROGRAM,;t t ++s,@AWK@,$AWK,;t t ++s,@SET_MAKE@,$SET_MAKE,;t t ++s,@AS@,$AS,;t t ++s,@ac_ct_AS@,$ac_ct_AS,;t t ++s,@AR@,$AR,;t t ++s,@ac_ct_AR@,$ac_ct_AR,;t t ++s,@RANLIB@,$RANLIB,;t t ++s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t ++s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t ++s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t ++s,@MAINT@,$MAINT,;t t ++s,@GC_CFLAGS@,$GC_CFLAGS,;t t ++s,@CC@,$CC,;t t ++s,@CFLAGS@,$CFLAGS,;t t ++s,@LDFLAGS@,$LDFLAGS,;t t ++s,@CPPFLAGS@,$CPPFLAGS,;t t ++s,@ac_ct_CC@,$ac_ct_CC,;t t ++s,@EXEEXT@,$EXEEXT,;t t ++s,@OBJEXT@,$OBJEXT,;t t ++s,@DEPDIR@,$DEPDIR,;t t ++s,@am__include@,$am__include,;t t ++s,@am__quote@,$am__quote,;t t ++s,@AMDEP_TRUE@,$AMDEP_TRUE,;t t ++s,@AMDEP_FALSE@,$AMDEP_FALSE,;t t ++s,@AMDEPBACKSLASH@,$AMDEPBACKSLASH,;t t ++s,@CCDEPMODE@,$CCDEPMODE,;t t ++s,@LN_S@,$LN_S,;t t ++s,@ECHO@,$ECHO,;t t ++s,@CPP@,$CPP,;t t ++s,@EGREP@,$EGREP,;t t ++s,@LIBTOOL@,$LIBTOOL,;t t ++s,@THREADLIBS@,$THREADLIBS,;t t ++s,@POWERPC_DARWIN_TRUE@,$POWERPC_DARWIN_TRUE,;t t ++s,@POWERPC_DARWIN_FALSE@,$POWERPC_DARWIN_FALSE,;t t ++s,@EXTRA_TEST_LIBS@,$EXTRA_TEST_LIBS,;t t ++s,@target_all@,$target_all,;t t ++s,@CXX@,$CXX,;t t ++s,@INCLUDES@,$INCLUDES,;t t ++s,@CXXINCLUDES@,$CXXINCLUDES,;t t ++s,@addobjs@,$addobjs,;t t ++s,@MY_CFLAGS@,$MY_CFLAGS,;t t ++s,@USE_LIBDIR_TRUE@,$USE_LIBDIR_TRUE,;t t ++s,@USE_LIBDIR_FALSE@,$USE_LIBDIR_FALSE,;t t ++s,@LIB@&t@OBJS@,$LIB@&t@OBJS,;t t ++s,@LTLIBOBJS@,$LTLIBOBJS,;t t ++CEOF ++ ++_ACEOF ++ ++ cat >>$CONFIG_STATUS <<\_ACEOF ++ # Split the substitutions into bite-sized pieces for seds with ++ # small command number limits, like on Digital OSF/1 and HP-UX. ++ ac_max_sed_lines=48 ++ ac_sed_frag=1 # Number of current file. ++ ac_beg=1 # First line for current file. ++ ac_end=$ac_max_sed_lines # Line after last line for current file. ++ ac_more_lines=: ++ ac_sed_cmds= ++ while $ac_more_lines; do ++ if test $ac_beg -gt 1; then ++ sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag ++ else ++ sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag ++ fi ++ if test ! -s $tmp/subs.frag; then ++ ac_more_lines=false ++ else ++ # The purpose of the label and of the branching condition is to ++ # speed up the sed processing (if there are no `@' at all, there ++ # is no need to browse any of the substitutions). ++ # These are the two extra sed commands mentioned above. ++ (echo ':t ++ /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed ++ if test -z "$ac_sed_cmds"; then ++ ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed" ++ else ++ ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed" ++ fi ++ ac_sed_frag=`expr $ac_sed_frag + 1` ++ ac_beg=$ac_end ++ ac_end=`expr $ac_end + $ac_max_sed_lines` ++ fi ++ done ++ if test -z "$ac_sed_cmds"; then ++ ac_sed_cmds=cat ++ fi ++fi # test -n "$CONFIG_FILES" ++ ++_ACEOF ++cat >>$CONFIG_STATUS <<\_ACEOF ++for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue ++ # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in". ++ case $ac_file in ++ - | *:- | *:-:* ) # input from stdin ++ cat >$tmp/stdin ++ ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'` ++ ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;; ++ *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'` ++ ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;; ++ * ) ac_file_in=$ac_file.in ;; ++ esac ++ ++ # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories. ++ ac_dir=`(dirname "$ac_file") 2>/dev/null || ++$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ ++ X"$ac_file" : 'X\(//\)[^/]' \| \ ++ X"$ac_file" : 'X\(//\)$' \| \ ++ X"$ac_file" : 'X\(/\)' \| \ ++ . : '\(.\)' 2>/dev/null || ++echo X"$ac_file" | ++ sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; } ++ /^X\(\/\/\)[^/].*/{ s//\1/; q; } ++ /^X\(\/\/\)$/{ s//\1/; q; } ++ /^X\(\/\).*/{ s//\1/; q; } ++ s/.*/./; q'` ++ { if $as_mkdir_p; then ++ mkdir -p "$ac_dir" ++ else ++ as_dir="$ac_dir" ++ as_dirs= ++ while test ! -d "$as_dir"; do ++ as_dirs="$as_dir $as_dirs" ++ as_dir=`(dirname "$as_dir") 2>/dev/null || ++$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ ++ X"$as_dir" : 'X\(//\)[^/]' \| \ ++ X"$as_dir" : 'X\(//\)$' \| \ ++ X"$as_dir" : 'X\(/\)' \| \ ++ . : '\(.\)' 2>/dev/null || ++echo X"$as_dir" | ++ sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; } ++ /^X\(\/\/\)[^/].*/{ s//\1/; q; } ++ /^X\(\/\/\)$/{ s//\1/; q; } ++ /^X\(\/\).*/{ s//\1/; q; } ++ s/.*/./; q'` ++ done ++ test ! -n "$as_dirs" || mkdir $as_dirs ++ fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5 ++echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;} ++ { (exit 1); exit 1; }; }; } ++ ++ ac_builddir=. ++ ++if test "$ac_dir" != .; then ++ ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'` ++ # A "../" for each directory in $ac_dir_suffix. ++ ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'` ++else ++ ac_dir_suffix= ac_top_builddir= ++fi ++ ++case $srcdir in ++ .) # No --srcdir option. We are building in place. ++ ac_srcdir=. ++ if test -z "$ac_top_builddir"; then ++ ac_top_srcdir=. ++ else ++ ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'` ++ fi ;; ++ [\\/]* | ?:[\\/]* ) # Absolute path. ++ ac_srcdir=$srcdir$ac_dir_suffix; ++ ac_top_srcdir=$srcdir ;; ++ *) # Relative path. ++ ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix ++ ac_top_srcdir=$ac_top_builddir$srcdir ;; ++esac ++# Don't blindly perform a `cd "$ac_dir"/$ac_foo && pwd` since $ac_foo can be ++# absolute. ++ac_abs_builddir=`cd "$ac_dir" && cd $ac_builddir && pwd` ++ac_abs_top_builddir=`cd "$ac_dir" && cd ${ac_top_builddir}. && pwd` ++ac_abs_srcdir=`cd "$ac_dir" && cd $ac_srcdir && pwd` ++ac_abs_top_srcdir=`cd "$ac_dir" && cd $ac_top_srcdir && pwd` ++ ++ ++ case $INSTALL in ++ [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;; ++ *) ac_INSTALL=$ac_top_builddir$INSTALL ;; ++ esac ++ ++ if test x"$ac_file" != x-; then ++ { echo "$as_me:$LINENO: creating $ac_file" >&5 ++echo "$as_me: creating $ac_file" >&6;} ++ rm -f "$ac_file" ++ fi ++ # Let's still pretend it is `configure' which instantiates (i.e., don't ++ # use $as_me), people would be surprised to read: ++ # /* config.h. Generated by config.status. */ ++ if test x"$ac_file" = x-; then ++ configure_input= ++ else ++ configure_input="$ac_file. " ++ fi ++ configure_input=$configure_input"Generated from `echo $ac_file_in | ++ sed 's,.*/,,'` by configure." ++ ++ # First look for the input files in the build tree, otherwise in the ++ # src tree. ++ ac_file_inputs=`IFS=: ++ for f in $ac_file_in; do ++ case $f in ++ -) echo $tmp/stdin ;; ++ [\\/$]*) ++ # Absolute (can't be DOS-style, as IFS=:) ++ test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5 ++echo "$as_me: error: cannot find input file: $f" >&2;} ++ { (exit 1); exit 1; }; } ++ echo $f;; ++ *) # Relative ++ if test -f "$f"; then ++ # Build tree ++ echo $f ++ elif test -f "$srcdir/$f"; then ++ # Source tree ++ echo $srcdir/$f ++ else ++ # /dev/null tree ++ { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5 ++echo "$as_me: error: cannot find input file: $f" >&2;} ++ { (exit 1); exit 1; }; } ++ fi;; ++ esac ++ done` || { (exit 1); exit 1; } ++_ACEOF ++cat >>$CONFIG_STATUS <<_ACEOF ++ sed "$ac_vpsub ++$extrasub ++_ACEOF ++cat >>$CONFIG_STATUS <<\_ACEOF ++:t ++/@[a-zA-Z_][a-zA-Z_0-9]*@/!b ++s,@configure_input@,$configure_input,;t t ++s,@srcdir@,$ac_srcdir,;t t ++s,@abs_srcdir@,$ac_abs_srcdir,;t t ++s,@top_srcdir@,$ac_top_srcdir,;t t ++s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t ++s,@builddir@,$ac_builddir,;t t ++s,@abs_builddir@,$ac_abs_builddir,;t t ++s,@top_builddir@,$ac_top_builddir,;t t ++s,@abs_top_builddir@,$ac_abs_top_builddir,;t t ++s,@INSTALL@,$ac_INSTALL,;t t ++" $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out ++ rm -f $tmp/stdin ++ if test x"$ac_file" != x-; then ++ mv $tmp/out $ac_file ++ else ++ cat $tmp/out ++ rm -f $tmp/out ++ fi ++ ++done ++_ACEOF ++cat >>$CONFIG_STATUS <<\_ACEOF ++ ++# ++# CONFIG_COMMANDS section. ++# ++for ac_file in : $CONFIG_COMMANDS; do test "x$ac_file" = x: && continue ++ ac_dest=`echo "$ac_file" | sed 's,:.*,,'` ++ ac_source=`echo "$ac_file" | sed 's,[^:]*:,,'` ++ ac_dir=`(dirname "$ac_dest") 2>/dev/null || ++$as_expr X"$ac_dest" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ ++ X"$ac_dest" : 'X\(//\)[^/]' \| \ ++ X"$ac_dest" : 'X\(//\)$' \| \ ++ X"$ac_dest" : 'X\(/\)' \| \ ++ . : '\(.\)' 2>/dev/null || ++echo X"$ac_dest" | ++ sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; } ++ /^X\(\/\/\)[^/].*/{ s//\1/; q; } ++ /^X\(\/\/\)$/{ s//\1/; q; } ++ /^X\(\/\).*/{ s//\1/; q; } ++ s/.*/./; q'` ++ ac_builddir=. ++ ++if test "$ac_dir" != .; then ++ ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'` ++ # A "../" for each directory in $ac_dir_suffix. ++ ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'` ++else ++ ac_dir_suffix= ac_top_builddir= ++fi ++ ++case $srcdir in ++ .) # No --srcdir option. We are building in place. ++ ac_srcdir=. ++ if test -z "$ac_top_builddir"; then ++ ac_top_srcdir=. ++ else ++ ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'` ++ fi ;; ++ [\\/]* | ?:[\\/]* ) # Absolute path. ++ ac_srcdir=$srcdir$ac_dir_suffix; ++ ac_top_srcdir=$srcdir ;; ++ *) # Relative path. ++ ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix ++ ac_top_srcdir=$ac_top_builddir$srcdir ;; ++esac ++# Don't blindly perform a `cd "$ac_dir"/$ac_foo && pwd` since $ac_foo can be ++# absolute. ++ac_abs_builddir=`cd "$ac_dir" && cd $ac_builddir && pwd` ++ac_abs_top_builddir=`cd "$ac_dir" && cd ${ac_top_builddir}. && pwd` ++ac_abs_srcdir=`cd "$ac_dir" && cd $ac_srcdir && pwd` ++ac_abs_top_srcdir=`cd "$ac_dir" && cd $ac_top_srcdir && pwd` ++ ++ ++ { echo "$as_me:$LINENO: executing $ac_dest commands" >&5 ++echo "$as_me: executing $ac_dest commands" >&6;} ++ case $ac_dest in ++ depfiles ) test x"$AMDEP_TRUE" != x"" || for mf in $CONFIG_FILES; do ++ # Strip MF so we end up with the name of the file. ++ mf=`echo "$mf" | sed -e 's/:.*$//'` ++ if (sed 1q $mf | fgrep 'generated by automake') > /dev/null 2>&1; then ++ dirpart=`(dirname "$mf") 2>/dev/null || ++$as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ ++ X"$mf" : 'X\(//\)[^/]' \| \ ++ X"$mf" : 'X\(//\)$' \| \ ++ X"$mf" : 'X\(/\)' \| \ ++ . : '\(.\)' 2>/dev/null || ++echo X"$mf" | ++ sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; } ++ /^X\(\/\/\)[^/].*/{ s//\1/; q; } ++ /^X\(\/\/\)$/{ s//\1/; q; } ++ /^X\(\/\).*/{ s//\1/; q; } ++ s/.*/./; q'` ++ else ++ continue ++ fi ++ grep '^DEP_FILES *= *[^ @%:@]' < "$mf" > /dev/null || continue ++ # Extract the definition of DEP_FILES from the Makefile without ++ # running `make'. ++ DEPDIR=`sed -n -e '/^DEPDIR = / s///p' < "$mf"` ++ test -z "$DEPDIR" && continue ++ # When using ansi2knr, U may be empty or an underscore; expand it ++ U=`sed -n -e '/^U = / s///p' < "$mf"` ++ test -d "$dirpart/$DEPDIR" || mkdir "$dirpart/$DEPDIR" ++ # We invoke sed twice because it is the simplest approach to ++ # changing $(DEPDIR) to its actual value in the expansion. ++ for file in `sed -n -e ' ++ /^DEP_FILES = .*\\\\$/ { ++ s/^DEP_FILES = // ++ :loop ++ s/\\\\$// ++ p ++ n ++ /\\\\$/ b loop ++ p ++ } ++ /^DEP_FILES = / s/^DEP_FILES = //p' < "$mf" | \ ++ sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do ++ # Make sure the directory exists. ++ test -f "$dirpart/$file" && continue ++ fdir=`(dirname "$file") 2>/dev/null || ++$as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ ++ X"$file" : 'X\(//\)[^/]' \| \ ++ X"$file" : 'X\(//\)$' \| \ ++ X"$file" : 'X\(/\)' \| \ ++ . : '\(.\)' 2>/dev/null || ++echo X"$file" | ++ sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; } ++ /^X\(\/\/\)[^/].*/{ s//\1/; q; } ++ /^X\(\/\/\)$/{ s//\1/; q; } ++ /^X\(\/\).*/{ s//\1/; q; } ++ s/.*/./; q'` ++ { if $as_mkdir_p; then ++ mkdir -p $dirpart/$fdir ++ else ++ as_dir=$dirpart/$fdir ++ as_dirs= ++ while test ! -d "$as_dir"; do ++ as_dirs="$as_dir $as_dirs" ++ as_dir=`(dirname "$as_dir") 2>/dev/null || ++$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ ++ X"$as_dir" : 'X\(//\)[^/]' \| \ ++ X"$as_dir" : 'X\(//\)$' \| \ ++ X"$as_dir" : 'X\(/\)' \| \ ++ . : '\(.\)' 2>/dev/null || ++echo X"$as_dir" | ++ sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; } ++ /^X\(\/\/\)[^/].*/{ s//\1/; q; } ++ /^X\(\/\/\)$/{ s//\1/; q; } ++ /^X\(\/\).*/{ s//\1/; q; } ++ s/.*/./; q'` ++ done ++ test ! -n "$as_dirs" || mkdir $as_dirs ++ fi || { { echo "$as_me:$LINENO: error: cannot create directory $dirpart/$fdir" >&5 ++echo "$as_me: error: cannot create directory $dirpart/$fdir" >&2;} ++ { (exit 1); exit 1; }; }; } ++ ++ # echo "creating $dirpart/$file" ++ echo '# dummy' > "$dirpart/$file" ++ done ++done ++ ;; ++ default ) ++echo "$DEFS" > boehm-cflags ++ ++if test -n "$CONFIG_FILES"; then ++ LD="${ORIGINAL_LD_FOR_MULTILIBS}" ++ ac_file=Makefile . ${gc_basedir}/../config-ml.in ++fi ;; ++ esac ++done ++_ACEOF ++ ++cat >>$CONFIG_STATUS <<\_ACEOF ++ ++{ (exit 0); exit 0; } ++_ACEOF ++chmod +x $CONFIG_STATUS ++ac_clean_files=$ac_clean_files_save ++ ++ ++# configure is writing to config.log, and then calls config.status. ++# config.status does its own redirection, appending to config.log. ++# Unfortunately, on DOS this fails, as config.log is still kept open ++# by configure, so config.status won't be able to write to it; its ++# output is simply discarded. So we exec the FD to /dev/null, ++# effectively closing config.log, so it can be properly (re)opened and ++# appended to by config.status. When coming back to configure, we ++# need to make the FD available again. ++if test "$no_create" != yes; then ++ ac_cs_success=: ++ exec 5>/dev/null ++ $SHELL $CONFIG_STATUS || ac_cs_success=false ++ exec 5>>config.log ++ # Use ||, not &&, to avoid exiting from the if with $? = 1, which ++ # would make configure fail if this is the last instruction. ++ $ac_cs_success || { (exit 1); exit 1; } ++fi ++ +diff -urNb boehm-gc/autom4te.cache/requests boehm-gc/autom4te.cache/requests +--- boehm-gc/autom4te.cache/requests Wed Dec 31 16:00:00 1969 ++++ boehm-gc/autom4te.cache/requests Sat May 31 15:09:32 2003 +@@ -0,0 +1,198 @@ ++# This file was created by autom4te-2.54. ++# It contains the lists of macros which have been traced. ++# It can be safely removed. ++ ++@request = ( ++ bless( [ ++ '0', ++ 0, ++ [ ++ '/sw/share/autoconf' ++ ], ++ [ ++ '/sw/share/autoconf/autoconf/autoconf.m4f', ++ 'aclocal.m4', ++ 'configure.in' ++ ], ++ { ++ 'm4_pattern_forbid' => 1, ++ 'AC_C_VOLATILE' => 1, ++ 'AC_TYPE_OFF_T' => 1, ++ 'AC_FUNC_CLOSEDIR_VOID' => 1, ++ 'AC_REPLACE_FNMATCH' => 1, ++ 'AC_PROG_LIBTOOL' => 1, ++ 'AC_FUNC_STAT' => 1, ++ 'AC_FUNC_WAIT3' => 1, ++ 'AC_HEADER_TIME' => 1, ++ 'AC_FUNC_LSTAT' => 1, ++ 'AC_STRUCT_TM' => 1, ++ 'AM_AUTOMAKE_VERSION' => 1, ++ 'AC_FUNC_GETMNTENT' => 1, ++ 'AC_TYPE_MODE_T' => 1, ++ 'AC_FUNC_STRTOD' => 1, ++ 'AC_CHECK_HEADERS' => 1, ++ 'AC_FUNC_STRNLEN' => 1, ++ 'AC_PROG_CXX' => 1, ++ 'AC_PATH_X' => 1, ++ 'AC_FUNC_LSTAT_FOLLOWS_SLASHED_SYMLINK' => 1, ++ 'AC_PROG_AWK' => 1, ++ 'AC_HEADER_STDC' => 1, ++ 'AC_HEADER_MAJOR' => 1, ++ 'AC_FUNC_ERROR_AT_LINE' => 1, ++ 'AC_PROG_GCC_TRADITIONAL' => 1, ++ 'AC_LIBSOURCE' => 1, ++ 'AC_FUNC_MBRTOWC' => 1, ++ 'AC_STRUCT_ST_BLOCKS' => 1, ++ 'AC_TYPE_SIGNAL' => 1, ++ 'AC_TYPE_UID_T' => 1, ++ 'AC_CONFIG_AUX_DIR' => 1, ++ 'AC_PROG_MAKE_SET' => 1, ++ 'm4_pattern_allow' => 1, ++ 'AC_DEFINE_TRACE_LITERAL' => 1, ++ 'AC_FUNC_STRERROR_R' => 1, ++ 'AC_PROG_CC' => 1, ++ 'AC_FUNC_FORK' => 1, ++ 'AC_DECL_SYS_SIGLIST' => 1, ++ 'AC_FUNC_STRCOLL' => 1, ++ 'AC_FUNC_VPRINTF' => 1, ++ 'AC_PROG_YACC' => 1, ++ 'AC_INIT' => 1, ++ 'AC_STRUCT_TIMEZONE' => 1, ++ 'AC_FUNC_CHOWN' => 1, ++ 'AC_SUBST' => 1, ++ 'AC_FUNC_ALLOCA' => 1, ++ 'AC_CANONICAL_HOST' => 1, ++ 'AC_FUNC_GETPGRP' => 1, ++ 'AC_PROG_RANLIB' => 1, ++ 'AM_INIT_AUTOMAKE' => 1, ++ 'AC_FUNC_SETPGRP' => 1, ++ 'AC_CONFIG_SUBDIRS' => 1, ++ 'AC_FUNC_MMAP' => 1, ++ 'AC_FUNC_REALLOC' => 1, ++ 'AC_TYPE_SIZE_T' => 1, ++ 'AC_CHECK_TYPES' => 1, ++ 'AC_CHECK_MEMBERS' => 1, ++ 'AM_MAINTAINER_MODE' => 1, ++ 'AC_FUNC_UTIME_NULL' => 1, ++ 'AC_FUNC_SELECT_ARGTYPES' => 1, ++ 'AC_FUNC_STRFTIME' => 1, ++ 'AC_HEADER_STAT' => 1, ++ 'AC_C_INLINE' => 1, ++ 'AC_PROG_CPP' => 1, ++ 'AC_TYPE_PID_T' => 1, ++ 'AC_PROG_LEX' => 1, ++ 'AC_C_CONST' => 1, ++ 'AC_CONFIG_FILES' => 1, ++ 'include' => 1, ++ 'AC_FUNC_SETVBUF_REVERSED' => 1, ++ 'AC_PROG_INSTALL' => 1, ++ 'AM_GNU_GETTEXT' => 1, ++ 'AC_CHECK_LIB' => 1, ++ 'AC_FUNC_OBSTACK' => 1, ++ 'AC_FUNC_MALLOC' => 1, ++ 'AC_FUNC_GETGROUPS' => 1, ++ 'AC_FUNC_GETLOADAVG' => 1, ++ 'AH_OUTPUT' => 1, ++ 'AC_FUNC_FSEEKO' => 1, ++ 'AM_PROG_CC_C_O' => 1, ++ 'AC_FUNC_MKTIME' => 1, ++ 'AC_CANONICAL_SYSTEM' => 1, ++ 'AM_CONDITIONAL' => 1, ++ 'AC_CONFIG_HEADERS' => 1, ++ 'AC_HEADER_SYS_WAIT' => 1, ++ 'AC_PROG_LN_S' => 1, ++ 'AC_FUNC_MEMCMP' => 1, ++ 'm4_include' => 1, ++ 'AC_HEADER_DIRENT' => 1, ++ 'AC_CHECK_FUNCS' => 1 ++ } ++ ], 'Request' ), ++ bless( [ ++ '1', ++ 1, ++ [ ++ '/sw/share/autoconf-2.54' ++ ], ++ [ ++ '--reload-state=/sw/share/autoconf-2.54/autoconf/autoconf.m4f', ++ 'aclocal.m4', ++ 'configure.in' ++ ], ++ { ++ 'm4_pattern_forbid' => 1, ++ 'AC_TYPE_OFF_T' => 1, ++ 'AC_PROG_LIBTOOL' => 1, ++ 'AC_FUNC_STAT' => 1, ++ 'AC_HEADER_TIME' => 1, ++ 'AC_FUNC_WAIT3' => 1, ++ 'AC_STRUCT_TM' => 1, ++ 'AC_FUNC_LSTAT' => 1, ++ 'AC_TYPE_MODE_T' => 1, ++ 'AC_FUNC_STRTOD' => 1, ++ 'AC_CHECK_HEADERS' => 1, ++ 'AC_PROG_CXX' => 1, ++ 'AC_PATH_X' => 1, ++ 'AC_PROG_AWK' => 1, ++ 'AC_HEADER_STDC' => 1, ++ 'AC_HEADER_MAJOR' => 1, ++ 'AC_FUNC_ERROR_AT_LINE' => 1, ++ 'AC_PROG_GCC_TRADITIONAL' => 1, ++ 'AC_LIBSOURCE' => 1, ++ 'AC_STRUCT_ST_BLOCKS' => 1, ++ 'AC_TYPE_SIGNAL' => 1, ++ 'AC_TYPE_UID_T' => 1, ++ 'AC_PROG_MAKE_SET' => 1, ++ 'm4_pattern_allow' => 1, ++ 'AC_DEFINE_TRACE_LITERAL' => 1, ++ 'AM_PROG_LIBTOOL' => 1, ++ 'AC_FUNC_STRERROR_R' => 1, ++ 'AC_PROG_CC' => 1, ++ 'AC_FUNC_FORK' => 1, ++ 'AC_DECL_SYS_SIGLIST' => 1, ++ 'AC_FUNC_STRCOLL' => 1, ++ 'AC_FUNC_VPRINTF' => 1, ++ 'AC_PROG_YACC' => 1, ++ 'AC_STRUCT_TIMEZONE' => 1, ++ 'AC_FUNC_CHOWN' => 1, ++ 'AC_SUBST' => 1, ++ 'AC_FUNC_ALLOCA' => 1, ++ 'AC_FUNC_GETPGRP' => 1, ++ 'AC_PROG_RANLIB' => 1, ++ 'AC_FUNC_SETPGRP' => 1, ++ 'AC_FUNC_MMAP' => 1, ++ 'AC_TYPE_SIZE_T' => 1, ++ 'AC_CHECK_TYPES' => 1, ++ 'AC_FUNC_UTIME_NULL' => 1, ++ 'AC_FUNC_STRFTIME' => 1, ++ 'AC_HEADER_STAT' => 1, ++ 'AC_C_INLINE' => 1, ++ 'AC_PROG_CPP' => 1, ++ 'AC_C_CONST' => 1, ++ 'AC_PROG_LEX' => 1, ++ 'AC_TYPE_PID_T' => 1, ++ 'AC_CONFIG_FILES' => 1, ++ 'include' => 1, ++ 'AC_FUNC_SETVBUF_REVERSED' => 1, ++ 'AC_FUNC_FNMATCH' => 1, ++ 'AC_PROG_INSTALL' => 1, ++ 'AM_GNU_GETTEXT' => 1, ++ 'AC_FUNC_OBSTACK' => 1, ++ 'AC_CHECK_LIB' => 1, ++ 'AC_FUNC_MALLOC' => 1, ++ 'AC_FUNC_GETGROUPS' => 1, ++ 'AC_FUNC_GETLOADAVG' => 1, ++ 'AH_OUTPUT' => 1, ++ 'AC_FUNC_FSEEKO' => 1, ++ 'AC_FUNC_MKTIME' => 1, ++ 'AM_CONDITIONAL' => 1, ++ 'AC_CONFIG_HEADERS' => 1, ++ 'AC_HEADER_SYS_WAIT' => 1, ++ 'AC_PROG_LN_S' => 1, ++ 'AC_FUNC_MEMCMP' => 1, ++ 'm4_include' => 1, ++ 'AC_HEADER_DIRENT' => 1, ++ 'AC_CHECK_FUNCS' => 1 ++ } ++ ], 'Request' ) ++ ); ++ +diff -urNb boehm-gc/autom4te.cache/traces.0 boehm-gc/autom4te.cache/traces.0 +--- boehm-gc/autom4te.cache/traces.0 Wed Dec 31 16:00:00 1969 ++++ boehm-gc/autom4te.cache/traces.0 Mon May 26 13:14:22 2003 +@@ -0,0 +1,185 @@ ++m4trace:configure.in:16: -1- AC_INIT([gcj_mlc.c]) ++m4trace:configure.in:16: -1- m4_pattern_forbid([^_?A[CHUM]_]) ++m4trace:configure.in:16: -1- m4_pattern_forbid([_AC_]) ++m4trace:configure.in:16: -1- m4_pattern_forbid([^LIBOBJS$], [do not use LIBOBJS directly, use AC_LIBOBJ (see section `AC_LIBOBJ vs LIBOBJS']) ++m4trace:configure.in:16: -1- m4_pattern_allow([^AS_FLAGS$]) ++m4trace:configure.in:16: -1- m4_pattern_forbid([^_?m4_]) ++m4trace:configure.in:16: -1- m4_pattern_forbid([^dnl$]) ++m4trace:configure.in:16: -1- m4_pattern_forbid([^_?AS_]) ++m4trace:configure.in:16: -1- AC_SUBST([SHELL], [${CONFIG_SHELL-/bin/sh}]) ++m4trace:configure.in:16: -1- AC_SUBST([PATH_SEPARATOR]) ++m4trace:configure.in:16: -1- AC_SUBST([PACKAGE_NAME], [m4_ifdef([AC_PACKAGE_NAME], ['AC_PACKAGE_NAME'])]) ++m4trace:configure.in:16: -1- AC_SUBST([PACKAGE_TARNAME], [m4_ifdef([AC_PACKAGE_TARNAME], ['AC_PACKAGE_TARNAME'])]) ++m4trace:configure.in:16: -1- AC_SUBST([PACKAGE_VERSION], [m4_ifdef([AC_PACKAGE_VERSION], ['AC_PACKAGE_VERSION'])]) ++m4trace:configure.in:16: -1- AC_SUBST([PACKAGE_STRING], [m4_ifdef([AC_PACKAGE_STRING], ['AC_PACKAGE_STRING'])]) ++m4trace:configure.in:16: -1- AC_SUBST([PACKAGE_BUGREPORT], [m4_ifdef([AC_PACKAGE_BUGREPORT], ['AC_PACKAGE_BUGREPORT'])]) ++m4trace:configure.in:16: -1- AC_SUBST([exec_prefix], [NONE]) ++m4trace:configure.in:16: -1- AC_SUBST([prefix], [NONE]) ++m4trace:configure.in:16: -1- AC_SUBST([program_transform_name], [s,x,x,]) ++m4trace:configure.in:16: -1- AC_SUBST([bindir], ['${exec_prefix}/bin']) ++m4trace:configure.in:16: -1- AC_SUBST([sbindir], ['${exec_prefix}/sbin']) ++m4trace:configure.in:16: -1- AC_SUBST([libexecdir], ['${exec_prefix}/libexec']) ++m4trace:configure.in:16: -1- AC_SUBST([datadir], ['${prefix}/share']) ++m4trace:configure.in:16: -1- AC_SUBST([sysconfdir], ['${prefix}/etc']) ++m4trace:configure.in:16: -1- AC_SUBST([sharedstatedir], ['${prefix}/com']) ++m4trace:configure.in:16: -1- AC_SUBST([localstatedir], ['${prefix}/var']) ++m4trace:configure.in:16: -1- AC_SUBST([libdir], ['${exec_prefix}/lib']) ++m4trace:configure.in:16: -1- AC_SUBST([includedir], ['${prefix}/include']) ++m4trace:configure.in:16: -1- AC_SUBST([oldincludedir], ['/usr/include']) ++m4trace:configure.in:16: -1- AC_SUBST([infodir], ['${prefix}/info']) ++m4trace:configure.in:16: -1- AC_SUBST([mandir], ['${prefix}/man']) ++m4trace:configure.in:16: -1- AC_DEFINE_TRACE_LITERAL([PACKAGE_NAME]) ++m4trace:configure.in:16: -1- AH_OUTPUT([PACKAGE_NAME], [/* Define to the full name of this package. */ ++#undef PACKAGE_NAME]) ++m4trace:configure.in:16: -1- AC_DEFINE_TRACE_LITERAL([PACKAGE_TARNAME]) ++m4trace:configure.in:16: -1- AH_OUTPUT([PACKAGE_TARNAME], [/* Define to the one symbol short name of this package. */ ++#undef PACKAGE_TARNAME]) ++m4trace:configure.in:16: -1- AC_DEFINE_TRACE_LITERAL([PACKAGE_VERSION]) ++m4trace:configure.in:16: -1- AH_OUTPUT([PACKAGE_VERSION], [/* Define to the version of this package. */ ++#undef PACKAGE_VERSION]) ++m4trace:configure.in:16: -1- AC_DEFINE_TRACE_LITERAL([PACKAGE_STRING]) ++m4trace:configure.in:16: -1- AH_OUTPUT([PACKAGE_STRING], [/* Define to the full name and version of this package. */ ++#undef PACKAGE_STRING]) ++m4trace:configure.in:16: -1- AC_DEFINE_TRACE_LITERAL([PACKAGE_BUGREPORT]) ++m4trace:configure.in:16: -1- AH_OUTPUT([PACKAGE_BUGREPORT], [/* Define to the address where bug reports for this package should be sent. */ ++#undef PACKAGE_BUGREPORT]) ++m4trace:configure.in:16: -1- AC_SUBST([build_alias]) ++m4trace:configure.in:16: -1- AC_SUBST([host_alias]) ++m4trace:configure.in:16: -1- AC_SUBST([target_alias]) ++m4trace:configure.in:16: -1- AC_SUBST([DEFS]) ++m4trace:configure.in:16: -1- AC_SUBST([ECHO_C]) ++m4trace:configure.in:16: -1- AC_SUBST([ECHO_N]) ++m4trace:configure.in:16: -1- AC_SUBST([ECHO_T]) ++m4trace:configure.in:16: -1- AC_SUBST([LIBS]) ++m4trace:configure.in:25: -1- AC_CONFIG_AUX_DIR([.]) ++m4trace:configure.in:27: -1- AC_SUBST([gc_basedir]) ++m4trace:configure.in:27: -1- AC_CONFIG_AUX_DIR([$gc_basedir/..]) ++m4trace:configure.in:27: -1- AC_CONFIG_AUX_DIR([..]) ++m4trace:configure.in:27: -1- AC_CANONICAL_SYSTEM ++m4trace:configure.in:27: -1- AC_CANONICAL_HOST ++m4trace:configure.in:27: -1- AC_SUBST([build], [$ac_cv_build]) ++m4trace:configure.in:27: -1- AC_SUBST([build_cpu], [`echo $ac_cv_build | sed 's/^\([[^-]]*\)-\([[^-]]*\)-\(.*\)$/\1/'`]) ++m4trace:configure.in:27: -1- AC_SUBST([build_vendor], [`echo $ac_cv_build | sed 's/^\([[^-]]*\)-\([[^-]]*\)-\(.*\)$/\2/'`]) ++m4trace:configure.in:27: -1- AC_SUBST([build_os], [`echo $ac_cv_build | sed 's/^\([[^-]]*\)-\([[^-]]*\)-\(.*\)$/\3/'`]) ++m4trace:configure.in:27: -1- AC_SUBST([host], [$ac_cv_host]) ++m4trace:configure.in:27: -1- AC_SUBST([host_cpu], [`echo $ac_cv_host | sed 's/^\([[^-]]*\)-\([[^-]]*\)-\(.*\)$/\1/'`]) ++m4trace:configure.in:27: -1- AC_SUBST([host_vendor], [`echo $ac_cv_host | sed 's/^\([[^-]]*\)-\([[^-]]*\)-\(.*\)$/\2/'`]) ++m4trace:configure.in:27: -1- AC_SUBST([host_os], [`echo $ac_cv_host | sed 's/^\([[^-]]*\)-\([[^-]]*\)-\(.*\)$/\3/'`]) ++m4trace:configure.in:27: -1- AC_SUBST([target], [$ac_cv_target]) ++m4trace:configure.in:27: -1- AC_SUBST([target_cpu], [`echo $ac_cv_target | sed 's/^\([[^-]]*\)-\([[^-]]*\)-\(.*\)$/\1/'`]) ++m4trace:configure.in:27: -1- AC_SUBST([target_vendor], [`echo $ac_cv_target | sed 's/^\([[^-]]*\)-\([[^-]]*\)-\(.*\)$/\2/'`]) ++m4trace:configure.in:27: -1- AC_SUBST([target_os], [`echo $ac_cv_target | sed 's/^\([[^-]]*\)-\([[^-]]*\)-\(.*\)$/\3/'`]) ++m4trace:configure.in:27: -1- AC_SUBST([mkinstalldirs]) ++m4trace:configure.in:27: -1- AM_INIT_AUTOMAKE([gc], [6.0], [no-define]) ++m4trace:configure.in:27: -1- AC_PROG_INSTALL ++m4trace:configure.in:27: -1- AC_SUBST([INSTALL_PROGRAM]) ++m4trace:configure.in:27: -1- AC_SUBST([INSTALL_SCRIPT]) ++m4trace:configure.in:27: -1- AC_SUBST([INSTALL_DATA]) ++m4trace:configure.in:27: -1- AC_SUBST([PACKAGE]) ++m4trace:configure.in:27: -1- AC_SUBST([VERSION]) ++m4trace:configure.in:27: -2- AC_DEFINE_TRACE_LITERAL([PACKAGE]) ++m4trace:configure.in:27: -2- AH_OUTPUT([PACKAGE], [/* Name of package */ ++#undef PACKAGE]) ++m4trace:configure.in:27: -2- AC_DEFINE_TRACE_LITERAL([VERSION]) ++m4trace:configure.in:27: -2- AH_OUTPUT([VERSION], [/* Version number of package */ ++#undef VERSION]) ++m4trace:configure.in:27: -1- AC_SUBST([ACLOCAL]) ++m4trace:configure.in:27: -1- AC_SUBST([AUTOCONF]) ++m4trace:configure.in:27: -1- AC_SUBST([AUTOMAKE]) ++m4trace:configure.in:27: -1- AC_SUBST([AUTOHEADER]) ++m4trace:configure.in:27: -1- AC_SUBST([MAKEINFO]) ++m4trace:configure.in:27: -1- AC_PROG_MAKE_SET ++m4trace:configure.in:27: -1- AC_SUBST([SET_MAKE]) ++m4trace:configure.in:27: -1- AC_SUBST([CC]) ++m4trace:configure.in:27: -1- AC_SUBST([CC]) ++m4trace:configure.in:27: -1- AC_SUBST([CXX]) ++m4trace:configure.in:27: -1- AC_SUBST([AS]) ++m4trace:configure.in:27: -1- AC_SUBST([ac_ct_AS]) ++m4trace:configure.in:27: -1- AC_SUBST([AR]) ++m4trace:configure.in:27: -1- AC_SUBST([ac_ct_AR]) ++m4trace:configure.in:27: -1- AC_SUBST([RANLIB]) ++m4trace:configure.in:27: -1- AC_SUBST([ac_ct_RANLIB]) ++m4trace:configure.in:27: -1- AC_PROG_INSTALL ++m4trace:configure.in:27: -1- AC_SUBST([INSTALL_PROGRAM]) ++m4trace:configure.in:27: -1- AC_SUBST([INSTALL_SCRIPT]) ++m4trace:configure.in:27: -1- AC_SUBST([INSTALL_DATA]) ++m4trace:configure.in:27: -1- AM_MAINTAINER_MODE ++m4trace:configure.in:27: -1- AM_CONDITIONAL([MAINTAINER_MODE], [test $USE_MAINTAINER_MODE = yes]) ++m4trace:configure.in:27: -1- AC_SUBST([MAINTAINER_MODE_TRUE]) ++m4trace:configure.in:27: -1- AC_SUBST([MAINTAINER_MODE_FALSE]) ++m4trace:configure.in:27: -1- AC_SUBST([MAINT]) ++m4trace:configure.in:27: -1- AC_SUBST([GC_CFLAGS]) ++m4trace:configure.in:29: -1- AC_PROG_LIBTOOL ++m4trace:configure.in:29: -1- AC_PROG_LN_S ++m4trace:configure.in:29: -1- AC_SUBST([LN_S], [$as_ln_s]) ++m4trace:configure.in:29: -1- AC_SUBST([RANLIB]) ++m4trace:configure.in:29: -1- AC_SUBST([ac_ct_RANLIB]) ++m4trace:configure.in:29: -1- AC_SUBST([STRIP]) ++m4trace:configure.in:29: -1- AC_SUBST([ac_ct_STRIP]) ++m4trace:configure.in:29: -1- AC_SUBST([LIBTOOL]) ++m4trace:configure.in:29: -1- AC_SUBST([CXXCPP]) ++m4trace:configure.in:29: -1- AC_SUBST([CPPFLAGS]) ++m4trace:configure.in:29: -1- AC_SUBST([CXXCPP]) ++m4trace:configure.in:38: -1- AM_MAINTAINER_MODE ++m4trace:configure.in:38: -1- AM_CONDITIONAL([MAINTAINER_MODE], [test $USE_MAINTAINER_MODE = yes]) ++m4trace:configure.in:38: -1- AC_SUBST([MAINTAINER_MODE_TRUE]) ++m4trace:configure.in:38: -1- AC_SUBST([MAINTAINER_MODE_FALSE]) ++m4trace:configure.in:38: -1- AC_SUBST([MAINT]) ++m4trace:configure.in:77: -1- AC_DEFINE_TRACE_LITERAL([GC_LINUX_THREADS]) ++m4trace:configure.in:78: -1- AC_DEFINE_TRACE_LITERAL([_REENTRANT]) ++m4trace:configure.in:80: -1- AC_DEFINE_TRACE_LITERAL([PARALLEL_MARK]) ++m4trace:configure.in:82: -1- AC_DEFINE_TRACE_LITERAL([THREAD_LOCAL_ALLOC]) ++m4trace:configure.in:85: -1- AC_DEFINE_TRACE_LITERAL([GC_LINUX_THREADS]) ++m4trace:configure.in:86: -1- AC_DEFINE_TRACE_LITERAL([_REENTRANT]) ++m4trace:configure.in:90: -1- AC_DEFINE_TRACE_LITERAL([GC_HPUX_THREADS]) ++m4trace:configure.in:91: -1- AC_DEFINE_TRACE_LITERAL([_POSIX_C_SOURCE]) ++m4trace:configure.in:93: -1- AC_DEFINE_TRACE_LITERAL([PARALLEL_MARK]) ++m4trace:configure.in:95: -1- AC_DEFINE_TRACE_LITERAL([THREAD_LOCAL_ALLOC]) ++m4trace:configure.in:100: -1- AC_DEFINE_TRACE_LITERAL([GC_FREEBSD_THREADS]) ++m4trace:configure.in:105: -1- AC_DEFINE_TRACE_LITERAL([GC_SOLARIS_THREADS]) ++m4trace:configure.in:106: -1- AC_DEFINE_TRACE_LITERAL([GC_SOLARIS_PTHREADS]) ++m4trace:configure.in:109: -1- AC_DEFINE_TRACE_LITERAL([GC_IRIX_THREADS]) ++m4trace:configure.in:117: -1- AC_DEFINE_TRACE_LITERAL([GC_DARWIN_THREADS]) ++m4trace:configure.in:118: -1- AC_DEFINE_TRACE_LITERAL([THREAD_LOCAL_ALLOC]) ++m4trace:configure.in:120: -1- AC_DEFINE_TRACE_LITERAL([PARALLEL_MARK]) ++m4trace:configure.in:124: -1- AC_DEFINE_TRACE_LITERAL([GC_WIN32_THREADS]) ++m4trace:configure.in:125: -1- AC_DEFINE_TRACE_LITERAL([NO_GETENV]) ++m4trace:configure.in:134: -1- AC_SUBST([THREADLIBS]) ++m4trace:configure.in:141: -1- AM_CONDITIONAL([POWERPC_DARWIN], [test x$powerpc_darwin = xtrue]) ++m4trace:configure.in:141: -1- AC_SUBST([POWERPC_DARWIN_TRUE]) ++m4trace:configure.in:141: -1- AC_SUBST([POWERPC_DARWIN_FALSE]) ++m4trace:configure.in:148: -1- AC_CHECK_LIB([dl], [dlopen], [EXTRA_TEST_LIBS="$EXTRA_TEST_LIBS -ldl"]) ++m4trace:configure.in:152: -1- AC_SUBST([EXTRA_TEST_LIBS]) ++m4trace:configure.in:155: -1- AC_SUBST([target_all]) ++m4trace:configure.in:156: -1- AC_SUBST([target_alias]) ++m4trace:configure.in:174: -1- AC_DEFINE_TRACE_LITERAL([ECOS]) ++m4trace:configure.in:179: -1- AC_SUBST([CXX]) ++m4trace:configure.in:181: -1- AC_SUBST([INCLUDES]) ++m4trace:configure.in:182: -1- AC_SUBST([CXXINCLUDES]) ++m4trace:configure.in:197: -1- AC_DEFINE_TRACE_LITERAL([SOLARIS25_PROC_VDB_BUG_FIXED]) ++m4trace:configure.in:201: -1- AC_DEFINE_TRACE_LITERAL([STACKBASE]) ++m4trace:configure.in:202: -1- AC_DEFINE_TRACE_LITERAL([DATASTART_IS_ETEXT]) ++m4trace:configure.in:211: -1- AC_DEFINE_TRACE_LITERAL([NO_EXECUTE_PERMISSION]) ++m4trace:configure.in:215: -1- AC_DEFINE_TRACE_LITERAL([SUNOS53_SHARED_LIB]) ++m4trace:configure.in:228: -1- AC_SUBST([addobjs]) ++m4trace:configure.in:252: -1- AC_SUBST([MY_CFLAGS]) ++m4trace:configure.in:256: -1- AC_DEFINE_TRACE_LITERAL([SILENT]) ++m4trace:configure.in:257: -1- AC_DEFINE_TRACE_LITERAL([NO_SIGNALS]) ++m4trace:configure.in:258: -1- AC_DEFINE_TRACE_LITERAL([NO_EXECUTE_PERMISSION]) ++m4trace:configure.in:259: -1- AC_DEFINE_TRACE_LITERAL([ALL_INTERIOR_POINTERS]) ++m4trace:configure.in:262: -1- AC_DEFINE_TRACE_LITERAL([JAVA_FINALIZATION]) ++m4trace:configure.in:263: -1- AC_DEFINE_TRACE_LITERAL([GC_GCJ_SUPPORT]) ++m4trace:configure.in:264: -1- AC_DEFINE_TRACE_LITERAL([ATOMIC_UNCOLLECTABLE]) ++m4trace:configure.in:270: -1- AC_DEFINE_TRACE_LITERAL([NO_SIGSET]) ++m4trace:configure.in:271: -1- AC_DEFINE_TRACE_LITERAL([NO_DEBUGGING]) ++m4trace:configure.in:290: -1- AC_DEFINE_TRACE_LITERAL([KEEP_BACK_PTRS]) ++m4trace:configure.in:290: -1- AC_DEFINE_TRACE_LITERAL([DBG_HDRS_ALL]) ++m4trace:configure.in:290: -1- AC_DEFINE_TRACE_LITERAL([MAKE_BACK_GRAPH]) ++m4trace:configure.in:290: -1- AC_DEFINE_TRACE_LITERAL([MAKE_BACK_GRAPH]) ++m4trace:configure.in:290: -1- AC_DEFINE_TRACE_LITERAL([SAVE_CALL_COUNT]) ++m4trace:configure.in:292: -1- AM_CONDITIONAL([USE_LIBDIR], [test -z "$with_cross_host"]) ++m4trace:configure.in:292: -1- AC_SUBST([USE_LIBDIR_TRUE]) ++m4trace:configure.in:292: -1- AC_SUBST([USE_LIBDIR_FALSE]) ++m4trace:configure.in:317: -1- AC_CONFIG_FILES([Makefile include/Makefile]) ++m4trace:configure.in:317: -1- AC_SUBST([LIB@&t@OBJS], [$ac_libobjs]) ++m4trace:configure.in:317: -1- AC_SUBST([LTLIBOBJS], [$ac_ltlibobjs]) +diff -urNb boehm-gc/autom4te.cache/traces.1 boehm-gc/autom4te.cache/traces.1 +--- boehm-gc/autom4te.cache/traces.1 Wed Dec 31 16:00:00 1969 ++++ boehm-gc/autom4te.cache/traces.1 Sat May 31 15:09:31 2003 +@@ -0,0 +1,250 @@ ++m4trace:aclocal.m4:166: -1- m4_pattern_allow([^AM_[A-Z]+FLAGS$]) ++m4trace:configure.in:16: -1- m4_pattern_forbid([^_?A[CHUM]_]) ++m4trace:configure.in:16: -1- m4_pattern_forbid([_AC_]) ++m4trace:configure.in:16: -1- m4_pattern_forbid([^LIBOBJS$], [do not use LIBOBJS directly, use AC_LIBOBJ (see section `AC_LIBOBJ vs LIBOBJS']) ++m4trace:configure.in:16: -1- m4_pattern_allow([^AS_FLAGS$]) ++m4trace:configure.in:16: -1- m4_pattern_forbid([^_?m4_]) ++m4trace:configure.in:16: -1- m4_pattern_forbid([^dnl$]) ++m4trace:configure.in:16: -1- m4_pattern_forbid([^_?AS_]) ++m4trace:configure.in:16: -1- AC_SUBST([SHELL], [${CONFIG_SHELL-/bin/sh}]) ++m4trace:configure.in:16: -1- AC_SUBST([PATH_SEPARATOR]) ++m4trace:configure.in:16: -1- AC_SUBST([PACKAGE_NAME], [m4_ifdef([AC_PACKAGE_NAME], ['AC_PACKAGE_NAME'])]) ++m4trace:configure.in:16: -1- AC_SUBST([PACKAGE_TARNAME], [m4_ifdef([AC_PACKAGE_TARNAME], ['AC_PACKAGE_TARNAME'])]) ++m4trace:configure.in:16: -1- AC_SUBST([PACKAGE_VERSION], [m4_ifdef([AC_PACKAGE_VERSION], ['AC_PACKAGE_VERSION'])]) ++m4trace:configure.in:16: -1- AC_SUBST([PACKAGE_STRING], [m4_ifdef([AC_PACKAGE_STRING], ['AC_PACKAGE_STRING'])]) ++m4trace:configure.in:16: -1- AC_SUBST([PACKAGE_BUGREPORT], [m4_ifdef([AC_PACKAGE_BUGREPORT], ['AC_PACKAGE_BUGREPORT'])]) ++m4trace:configure.in:16: -1- AC_SUBST([exec_prefix], [NONE]) ++m4trace:configure.in:16: -1- AC_SUBST([prefix], [NONE]) ++m4trace:configure.in:16: -1- AC_SUBST([program_transform_name], [s,x,x,]) ++m4trace:configure.in:16: -1- AC_SUBST([bindir], ['${exec_prefix}/bin']) ++m4trace:configure.in:16: -1- AC_SUBST([sbindir], ['${exec_prefix}/sbin']) ++m4trace:configure.in:16: -1- AC_SUBST([libexecdir], ['${exec_prefix}/libexec']) ++m4trace:configure.in:16: -1- AC_SUBST([datadir], ['${prefix}/share']) ++m4trace:configure.in:16: -1- AC_SUBST([sysconfdir], ['${prefix}/etc']) ++m4trace:configure.in:16: -1- AC_SUBST([sharedstatedir], ['${prefix}/com']) ++m4trace:configure.in:16: -1- AC_SUBST([localstatedir], ['${prefix}/var']) ++m4trace:configure.in:16: -1- AC_SUBST([libdir], ['${exec_prefix}/lib']) ++m4trace:configure.in:16: -1- AC_SUBST([includedir], ['${prefix}/include']) ++m4trace:configure.in:16: -1- AC_SUBST([oldincludedir], ['/usr/include']) ++m4trace:configure.in:16: -1- AC_SUBST([infodir], ['${prefix}/info']) ++m4trace:configure.in:16: -1- AC_SUBST([mandir], ['${prefix}/man']) ++m4trace:configure.in:16: -1- AC_DEFINE_TRACE_LITERAL([PACKAGE_NAME]) ++m4trace:configure.in:16: -1- AH_OUTPUT([PACKAGE_NAME], [/* Define to the full name of this package. */ ++#undef PACKAGE_NAME]) ++m4trace:configure.in:16: -1- AC_DEFINE_TRACE_LITERAL([PACKAGE_TARNAME]) ++m4trace:configure.in:16: -1- AH_OUTPUT([PACKAGE_TARNAME], [/* Define to the one symbol short name of this package. */ ++#undef PACKAGE_TARNAME]) ++m4trace:configure.in:16: -1- AC_DEFINE_TRACE_LITERAL([PACKAGE_VERSION]) ++m4trace:configure.in:16: -1- AH_OUTPUT([PACKAGE_VERSION], [/* Define to the version of this package. */ ++#undef PACKAGE_VERSION]) ++m4trace:configure.in:16: -1- AC_DEFINE_TRACE_LITERAL([PACKAGE_STRING]) ++m4trace:configure.in:16: -1- AH_OUTPUT([PACKAGE_STRING], [/* Define to the full name and version of this package. */ ++#undef PACKAGE_STRING]) ++m4trace:configure.in:16: -1- AC_DEFINE_TRACE_LITERAL([PACKAGE_BUGREPORT]) ++m4trace:configure.in:16: -1- AH_OUTPUT([PACKAGE_BUGREPORT], [/* Define to the address where bug reports for this package should be sent. */ ++#undef PACKAGE_BUGREPORT]) ++m4trace:configure.in:16: -1- AC_SUBST([build_alias]) ++m4trace:configure.in:16: -1- AC_SUBST([host_alias]) ++m4trace:configure.in:16: -1- AC_SUBST([target_alias]) ++m4trace:configure.in:16: -1- AC_SUBST([DEFS]) ++m4trace:configure.in:16: -1- AC_SUBST([ECHO_C]) ++m4trace:configure.in:16: -1- AC_SUBST([ECHO_N]) ++m4trace:configure.in:16: -1- AC_SUBST([ECHO_T]) ++m4trace:configure.in:16: -1- AC_SUBST([LIBS]) ++m4trace:configure.in:27: -1- AC_SUBST([gc_basedir]) ++m4trace:configure.in:27: -1- AC_SUBST([build], [$ac_cv_build]) ++m4trace:configure.in:27: -1- AC_SUBST([build_cpu], [`echo $ac_cv_build | sed 's/^\([[^-]]*\)-\([[^-]]*\)-\(.*\)$/\1/'`]) ++m4trace:configure.in:27: -1- AC_SUBST([build_vendor], [`echo $ac_cv_build | sed 's/^\([[^-]]*\)-\([[^-]]*\)-\(.*\)$/\2/'`]) ++m4trace:configure.in:27: -1- AC_SUBST([build_os], [`echo $ac_cv_build | sed 's/^\([[^-]]*\)-\([[^-]]*\)-\(.*\)$/\3/'`]) ++m4trace:configure.in:27: -1- AC_SUBST([host], [$ac_cv_host]) ++m4trace:configure.in:27: -1- AC_SUBST([host_cpu], [`echo $ac_cv_host | sed 's/^\([[^-]]*\)-\([[^-]]*\)-\(.*\)$/\1/'`]) ++m4trace:configure.in:27: -1- AC_SUBST([host_vendor], [`echo $ac_cv_host | sed 's/^\([[^-]]*\)-\([[^-]]*\)-\(.*\)$/\2/'`]) ++m4trace:configure.in:27: -1- AC_SUBST([host_os], [`echo $ac_cv_host | sed 's/^\([[^-]]*\)-\([[^-]]*\)-\(.*\)$/\3/'`]) ++m4trace:configure.in:27: -1- AC_SUBST([target], [$ac_cv_target]) ++m4trace:configure.in:27: -1- AC_SUBST([target_cpu], [`echo $ac_cv_target | sed 's/^\([[^-]]*\)-\([[^-]]*\)-\(.*\)$/\1/'`]) ++m4trace:configure.in:27: -1- AC_SUBST([target_vendor], [`echo $ac_cv_target | sed 's/^\([[^-]]*\)-\([[^-]]*\)-\(.*\)$/\2/'`]) ++m4trace:configure.in:27: -1- AC_SUBST([target_os], [`echo $ac_cv_target | sed 's/^\([[^-]]*\)-\([[^-]]*\)-\(.*\)$/\3/'`]) ++m4trace:configure.in:27: -1- AC_SUBST([mkinstalldirs]) ++m4trace:configure.in:27: -1- AC_PROG_INSTALL ++m4trace:configure.in:27: -1- AC_SUBST([INSTALL_PROGRAM]) ++m4trace:configure.in:27: -1- AC_SUBST([INSTALL_SCRIPT]) ++m4trace:configure.in:27: -1- AC_SUBST([INSTALL_DATA]) ++m4trace:configure.in:27: -1- AC_SUBST([PACKAGE], [gc]) ++m4trace:configure.in:27: -1- AC_SUBST([VERSION], [6.1a1]) ++m4trace:configure.in:27: -1- AC_SUBST([ACLOCAL]) ++m4trace:configure.in:27: -1- AC_SUBST([AUTOCONF]) ++m4trace:configure.in:27: -1- AC_SUBST([AUTOMAKE]) ++m4trace:configure.in:27: -1- AC_SUBST([AUTOHEADER]) ++m4trace:configure.in:27: -1- AC_SUBST([MAKEINFO]) ++m4trace:configure.in:27: -1- AC_SUBST([AMTAR]) ++m4trace:configure.in:27: -1- AC_SUBST([install_sh]) ++m4trace:configure.in:27: -1- AC_SUBST([STRIP]) ++m4trace:configure.in:27: -1- AC_SUBST([ac_ct_STRIP]) ++m4trace:configure.in:27: -1- AC_SUBST([INSTALL_STRIP_PROGRAM]) ++m4trace:configure.in:27: -1- AC_PROG_AWK ++m4trace:configure.in:27: -1- AC_SUBST([AWK]) ++m4trace:configure.in:27: -1- AC_PROG_MAKE_SET ++m4trace:configure.in:27: -1- AC_SUBST([SET_MAKE]) ++m4trace:configure.in:27: -1- AC_SUBST([AS]) ++m4trace:configure.in:27: -1- AC_SUBST([ac_ct_AS]) ++m4trace:configure.in:27: -1- AC_SUBST([AR]) ++m4trace:configure.in:27: -1- AC_SUBST([ac_ct_AR]) ++m4trace:configure.in:27: -1- AC_SUBST([RANLIB]) ++m4trace:configure.in:27: -1- AC_SUBST([ac_ct_RANLIB]) ++m4trace:configure.in:27: -1- AC_PROG_INSTALL ++m4trace:configure.in:27: -1- AC_SUBST([INSTALL_PROGRAM]) ++m4trace:configure.in:27: -1- AC_SUBST([INSTALL_SCRIPT]) ++m4trace:configure.in:27: -1- AC_SUBST([INSTALL_DATA]) ++m4trace:configure.in:27: -1- AM_CONDITIONAL([MAINTAINER_MODE], [test $USE_MAINTAINER_MODE = yes]) ++m4trace:configure.in:27: -1- AC_SUBST([MAINTAINER_MODE_TRUE]) ++m4trace:configure.in:27: -1- AC_SUBST([MAINTAINER_MODE_FALSE]) ++m4trace:configure.in:27: -1- AC_SUBST([MAINT]) ++m4trace:configure.in:27: -1- AC_SUBST([GC_CFLAGS]) ++m4trace:configure.in:29: -1- AM_PROG_LIBTOOL ++m4trace:configure.in:29: -1- AC_PROG_LIBTOOL ++m4trace:configure.in:29: -1- AC_PROG_CC ++m4trace:configure.in:29: -1- AC_SUBST([CC]) ++m4trace:configure.in:29: -1- AC_SUBST([CFLAGS]) ++m4trace:configure.in:29: -1- AC_SUBST([LDFLAGS]) ++m4trace:configure.in:29: -1- AC_SUBST([CPPFLAGS]) ++m4trace:configure.in:29: -1- AC_SUBST([CC]) ++m4trace:configure.in:29: -1- AC_SUBST([ac_ct_CC]) ++m4trace:configure.in:29: -1- AC_SUBST([CC]) ++m4trace:configure.in:29: -1- AC_SUBST([ac_ct_CC]) ++m4trace:configure.in:29: -1- AC_SUBST([CC]) ++m4trace:configure.in:29: -1- AC_SUBST([CC]) ++m4trace:configure.in:29: -1- AC_SUBST([ac_ct_CC]) ++m4trace:configure.in:29: -1- AC_SUBST([EXEEXT], [$ac_cv_exeext]) ++m4trace:configure.in:29: -1- AC_SUBST([OBJEXT], [$ac_cv_objext]) ++m4trace:configure.in:29: -1- AC_SUBST([DEPDIR]) ++m4trace:configure.in:29: -1- AC_SUBST([am__include]) ++m4trace:configure.in:29: -1- AC_SUBST([am__quote]) ++m4trace:configure.in:29: -1- AM_CONDITIONAL([AMDEP], [test "x$enable_dependency_tracking" != xno]) ++m4trace:configure.in:29: -1- AC_SUBST([AMDEP_TRUE]) ++m4trace:configure.in:29: -1- AC_SUBST([AMDEP_FALSE]) ++m4trace:configure.in:29: -1- AC_SUBST([AMDEPBACKSLASH]) ++m4trace:configure.in:29: -1- AC_SUBST([CCDEPMODE], [depmode=$am_cv_CC_dependencies_compiler_type]) ++m4trace:configure.in:29: -1- AC_PROG_LN_S ++m4trace:configure.in:29: -1- AC_SUBST([LN_S], [$as_ln_s]) ++m4trace:configure.in:29: -1- AC_SUBST([ECHO]) ++m4trace:configure.in:29: -1- AC_SUBST([RANLIB]) ++m4trace:configure.in:29: -1- AC_SUBST([ac_ct_RANLIB]) ++m4trace:configure.in:29: -1- AC_SUBST([STRIP]) ++m4trace:configure.in:29: -1- AC_SUBST([ac_ct_STRIP]) ++m4trace:configure.in:29: -1- AC_CHECK_LIB([dld], [shl_load], [lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-dld"], [AC_CHECK_FUNC([dlopen], ++ [lt_cv_dlopen="dlopen"], ++ [AC_CHECK_LIB([dl], [dlopen], ++ [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"], ++ [AC_CHECK_LIB([svld], [dlopen], ++ [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"], ++ [AC_CHECK_LIB([dld], [dld_link], ++ [lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-dld"]) ++ ]) ++ ]) ++ ]) ++ ]) ++m4trace:configure.in:29: -1- AC_CHECK_LIB([dl], [dlopen], [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"], [AC_CHECK_LIB([svld], [dlopen], ++ [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"], ++ [AC_CHECK_LIB([dld], [dld_link], ++ [lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-dld"]) ++ ]) ++ ]) ++m4trace:configure.in:29: -1- AC_CHECK_LIB([svld], [dlopen], [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"], [AC_CHECK_LIB([dld], [dld_link], ++ [lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-dld"]) ++ ]) ++m4trace:configure.in:29: -1- AC_CHECK_LIB([dld], [dld_link], [lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-dld"]) ++m4trace:configure.in:29: -1- AC_CHECK_HEADERS([dlfcn.h]) ++m4trace:configure.in:29: -1- AH_OUTPUT([HAVE_DLFCN_H], [/* Define to 1 if you have the header file. */ ++#undef HAVE_DLFCN_H]) ++m4trace:configure.in:29: -1- AC_HEADER_STDC ++m4trace:configure.in:29: -1- AC_PROG_CPP ++m4trace:configure.in:29: -1- AC_SUBST([CPP]) ++m4trace:configure.in:29: -1- AC_SUBST([CPPFLAGS]) ++m4trace:configure.in:29: -1- AC_SUBST([CPP]) ++m4trace:configure.in:29: -1- AC_SUBST([EGREP]) ++m4trace:configure.in:29: -1- AC_DEFINE_TRACE_LITERAL([STDC_HEADERS]) ++m4trace:configure.in:29: -1- AH_OUTPUT([STDC_HEADERS], [/* Define to 1 if you have the ANSI C header files. */ ++#undef STDC_HEADERS]) ++m4trace:configure.in:29: -1- AC_CHECK_HEADERS([sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \ ++ inttypes.h stdint.h unistd.h], [], [], [$ac_includes_default]) ++m4trace:configure.in:29: -1- AH_OUTPUT([HAVE_SYS_TYPES_H], [/* Define to 1 if you have the header file. */ ++#undef HAVE_SYS_TYPES_H]) ++m4trace:configure.in:29: -1- AH_OUTPUT([HAVE_SYS_STAT_H], [/* Define to 1 if you have the header file. */ ++#undef HAVE_SYS_STAT_H]) ++m4trace:configure.in:29: -1- AH_OUTPUT([HAVE_STDLIB_H], [/* Define to 1 if you have the header file. */ ++#undef HAVE_STDLIB_H]) ++m4trace:configure.in:29: -1- AH_OUTPUT([HAVE_STRING_H], [/* Define to 1 if you have the header file. */ ++#undef HAVE_STRING_H]) ++m4trace:configure.in:29: -1- AH_OUTPUT([HAVE_MEMORY_H], [/* Define to 1 if you have the header file. */ ++#undef HAVE_MEMORY_H]) ++m4trace:configure.in:29: -1- AH_OUTPUT([HAVE_STRINGS_H], [/* Define to 1 if you have the header file. */ ++#undef HAVE_STRINGS_H]) ++m4trace:configure.in:29: -1- AH_OUTPUT([HAVE_INTTYPES_H], [/* Define to 1 if you have the header file. */ ++#undef HAVE_INTTYPES_H]) ++m4trace:configure.in:29: -1- AH_OUTPUT([HAVE_STDINT_H], [/* Define to 1 if you have the header file. */ ++#undef HAVE_STDINT_H]) ++m4trace:configure.in:29: -1- AH_OUTPUT([HAVE_UNISTD_H], [/* Define to 1 if you have the header file. */ ++#undef HAVE_UNISTD_H]) ++m4trace:configure.in:29: -1- AC_SUBST([LIBTOOL]) ++m4trace:configure.in:38: -1- AM_CONDITIONAL([MAINTAINER_MODE], [test $USE_MAINTAINER_MODE = yes]) ++m4trace:configure.in:38: -1- AC_SUBST([MAINTAINER_MODE_TRUE]) ++m4trace:configure.in:38: -1- AC_SUBST([MAINTAINER_MODE_FALSE]) ++m4trace:configure.in:38: -1- AC_SUBST([MAINT]) ++m4trace:configure.in:77: -1- AC_DEFINE_TRACE_LITERAL([GC_LINUX_THREADS]) ++m4trace:configure.in:78: -1- AC_DEFINE_TRACE_LITERAL([_REENTRANT]) ++m4trace:configure.in:80: -1- AC_DEFINE_TRACE_LITERAL([PARALLEL_MARK]) ++m4trace:configure.in:82: -1- AC_DEFINE_TRACE_LITERAL([THREAD_LOCAL_ALLOC]) ++m4trace:configure.in:85: -1- AC_DEFINE_TRACE_LITERAL([GC_LINUX_THREADS]) ++m4trace:configure.in:86: -1- AC_DEFINE_TRACE_LITERAL([_REENTRANT]) ++m4trace:configure.in:90: -1- AC_DEFINE_TRACE_LITERAL([GC_HPUX_THREADS]) ++m4trace:configure.in:91: -1- AC_DEFINE_TRACE_LITERAL([_POSIX_C_SOURCE]) ++m4trace:configure.in:93: -1- AC_DEFINE_TRACE_LITERAL([PARALLEL_MARK]) ++m4trace:configure.in:95: -1- AC_DEFINE_TRACE_LITERAL([THREAD_LOCAL_ALLOC]) ++m4trace:configure.in:100: -1- AC_DEFINE_TRACE_LITERAL([GC_FREEBSD_THREADS]) ++m4trace:configure.in:105: -1- AC_DEFINE_TRACE_LITERAL([GC_SOLARIS_THREADS]) ++m4trace:configure.in:106: -1- AC_DEFINE_TRACE_LITERAL([GC_SOLARIS_PTHREADS]) ++m4trace:configure.in:109: -1- AC_DEFINE_TRACE_LITERAL([GC_IRIX_THREADS]) ++m4trace:configure.in:115: -1- AC_DEFINE_TRACE_LITERAL([GC_DARWIN_THREADS]) ++m4trace:configure.in:116: -1- AC_DEFINE_TRACE_LITERAL([THREAD_LOCAL_ALLOC]) ++m4trace:configure.in:118: -1- AC_DEFINE_TRACE_LITERAL([PARALLEL_MARK]) ++m4trace:configure.in:124: -1- AC_DEFINE_TRACE_LITERAL([GC_WIN32_THREADS]) ++m4trace:configure.in:125: -1- AC_DEFINE_TRACE_LITERAL([NO_GETENV]) ++m4trace:configure.in:134: -1- AC_SUBST([THREADLIBS]) ++m4trace:configure.in:141: -1- AM_CONDITIONAL([POWERPC_DARWIN], [test x$powerpc_darwin = xtrue]) ++m4trace:configure.in:141: -1- AC_SUBST([POWERPC_DARWIN_TRUE]) ++m4trace:configure.in:141: -1- AC_SUBST([POWERPC_DARWIN_FALSE]) ++m4trace:configure.in:148: -1- AC_CHECK_LIB([dl], [dlopen], [EXTRA_TEST_LIBS="$EXTRA_TEST_LIBS -ldl"]) ++m4trace:configure.in:152: -1- AC_SUBST([EXTRA_TEST_LIBS]) ++m4trace:configure.in:155: -1- AC_SUBST([target_all]) ++m4trace:configure.in:156: -1- AC_SUBST([target_alias]) ++m4trace:configure.in:174: -1- AC_DEFINE_TRACE_LITERAL([ECOS]) ++m4trace:configure.in:179: -1- AC_SUBST([CXX]) ++m4trace:configure.in:181: -1- AC_SUBST([INCLUDES]) ++m4trace:configure.in:182: -1- AC_SUBST([CXXINCLUDES]) ++m4trace:configure.in:197: -1- AC_DEFINE_TRACE_LITERAL([SOLARIS25_PROC_VDB_BUG_FIXED]) ++m4trace:configure.in:201: -1- AC_DEFINE_TRACE_LITERAL([STACKBASE]) ++m4trace:configure.in:202: -1- AC_DEFINE_TRACE_LITERAL([DATASTART_IS_ETEXT]) ++m4trace:configure.in:211: -1- AC_DEFINE_TRACE_LITERAL([NO_EXECUTE_PERMISSION]) ++m4trace:configure.in:215: -1- AC_DEFINE_TRACE_LITERAL([SUNOS53_SHARED_LIB]) ++m4trace:configure.in:228: -1- AC_SUBST([addobjs]) ++m4trace:configure.in:252: -1- AC_SUBST([MY_CFLAGS]) ++m4trace:configure.in:256: -1- AC_DEFINE_TRACE_LITERAL([SILENT]) ++m4trace:configure.in:257: -1- AC_DEFINE_TRACE_LITERAL([NO_SIGNALS]) ++m4trace:configure.in:258: -1- AC_DEFINE_TRACE_LITERAL([NO_EXECUTE_PERMISSION]) ++m4trace:configure.in:259: -1- AC_DEFINE_TRACE_LITERAL([ALL_INTERIOR_POINTERS]) ++m4trace:configure.in:262: -1- AC_DEFINE_TRACE_LITERAL([JAVA_FINALIZATION]) ++m4trace:configure.in:263: -1- AC_DEFINE_TRACE_LITERAL([GC_GCJ_SUPPORT]) ++m4trace:configure.in:264: -1- AC_DEFINE_TRACE_LITERAL([ATOMIC_UNCOLLECTABLE]) ++m4trace:configure.in:270: -1- AC_DEFINE_TRACE_LITERAL([NO_SIGSET]) ++m4trace:configure.in:271: -1- AC_DEFINE_TRACE_LITERAL([NO_DEBUGGING]) ++m4trace:configure.in:290: -1- AC_DEFINE_TRACE_LITERAL([KEEP_BACK_PTRS]) ++m4trace:configure.in:290: -1- AC_DEFINE_TRACE_LITERAL([DBG_HDRS_ALL]) ++m4trace:configure.in:290: -1- AC_DEFINE_TRACE_LITERAL([MAKE_BACK_GRAPH]) ++m4trace:configure.in:290: -1- AC_DEFINE_TRACE_LITERAL([MAKE_BACK_GRAPH]) ++m4trace:configure.in:290: -1- AC_DEFINE_TRACE_LITERAL([SAVE_CALL_COUNT]) ++m4trace:configure.in:292: -1- AM_CONDITIONAL([USE_LIBDIR], [test -z "$with_cross_host"]) ++m4trace:configure.in:292: -1- AC_SUBST([USE_LIBDIR_TRUE]) ++m4trace:configure.in:292: -1- AC_SUBST([USE_LIBDIR_FALSE]) ++m4trace:configure.in:317: -1- AC_CONFIG_FILES([Makefile include/Makefile]) ++m4trace:configure.in:317: -1- AC_SUBST([LIB@&t@OBJS], [$ac_libobjs]) ++m4trace:configure.in:317: -1- AC_SUBST([LTLIBOBJS], [$ac_ltlibobjs]) +diff -urNb boehm-gc/backgraph.c boehm-gc/backgraph.c +--- boehm-gc/backgraph.c Wed Jan 30 18:48:45 2002 ++++ boehm-gc/backgraph.c Mon May 26 12:48:52 2003 +@@ -307,6 +307,7 @@ + } + while (currentp < (word *)(p + gc_descr)) { + word current = *currentp++; ++ FIXUP_POINTER(current); + if (current >= (word)GC_least_plausible_heap_addr && + current <= (word)GC_greatest_plausible_heap_addr) { + ptr_t target = GC_base((GC_PTR)current); +diff -urNb boehm-gc/configure boehm-gc/configure +--- boehm-gc/configure Tue May 13 17:18:14 2003 ++++ boehm-gc/configure Sat May 31 21:21:37 2003 +@@ -61,7 +61,6 @@ + program_transform_name=s,x,x, + silent= + site= +-sitefile= + srcdir= + target=NONE + verbose= +@@ -176,7 +175,6 @@ + --help print this message + --no-create do not create output files + --quiet, --silent do not print \`checking...' messages +- --site-file=FILE use FILE as the site file + --version print the version of autoconf that created configure + Directory and file names: + --prefix=PREFIX install architecture-independent files in PREFIX +@@ -347,11 +345,6 @@ + -site=* | --site=* | --sit=*) + site="$ac_optarg" ;; + +- -site-file | --site-file | --site-fil | --site-fi | --site-f) +- ac_prev=sitefile ;; +- -site-file=* | --site-file=* | --site-fil=* | --site-fi=* | --site-f=*) +- sitefile="$ac_optarg" ;; +- + -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) + ac_prev=srcdir ;; + -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) +@@ -517,16 +510,12 @@ + srcdir=`echo "${srcdir}" | sed 's%\([^/]\)/*$%\1%'` + + # Prefer explicitly selected file to automatically selected ones. +-if test -z "$sitefile"; then +- if test -z "$CONFIG_SITE"; then ++if test -z "$CONFIG_SITE"; then + if test "x$prefix" != xNONE; then + CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site" + else + CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site" + fi +- fi +-else +- CONFIG_SITE="$sitefile" + fi + for ac_site_file in $CONFIG_SITE; do + if test -r "$ac_site_file"; then +@@ -604,7 +593,7 @@ + # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff" + # ./install, which can be erroneously created by make from ./install.sh. + echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6 +-echo "configure:608: checking for a BSD compatible install" >&5 ++echo "configure:597: checking for a BSD compatible install" >&5 + if test -z "$INSTALL"; then + if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +@@ -657,7 +646,7 @@ + test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644' + + echo $ac_n "checking whether build environment is sane""... $ac_c" 1>&6 +-echo "configure:661: checking whether build environment is sane" >&5 ++echo "configure:650: checking whether build environment is sane" >&5 + # Just in case + sleep 1 + echo timestamp > conftestfile +@@ -714,7 +703,7 @@ + test "$program_transform_name" = "" && program_transform_name="s,x,x," + + echo $ac_n "checking whether ${MAKE-make} sets \${MAKE}""... $ac_c" 1>&6 +-echo "configure:718: checking whether ${MAKE-make} sets \${MAKE}" >&5 ++echo "configure:707: checking whether ${MAKE-make} sets \${MAKE}" >&5 + set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y%./+-%__p_%'` + if eval "test \"`echo '$''{'ac_cv_prog_make_${ac_make}_set'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +@@ -747,12 +736,12 @@ + fi + + echo $ac_n "checking for Cygwin environment""... $ac_c" 1>&6 +-echo "configure:751: checking for Cygwin environment" >&5 ++echo "configure:740: checking for Cygwin environment" >&5 + if eval "test \"`echo '$''{'ac_cv_cygwin'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + cat > conftest.$ac_ext <&5; (eval $ac_compile) 2>&5; }; then ++if { (eval echo configure:756: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then + rm -rf conftest* + ac_cv_cygwin=yes + else +@@ -780,19 +769,19 @@ + CYGWIN= + test "$ac_cv_cygwin" = yes && CYGWIN=yes + echo $ac_n "checking for mingw32 environment""... $ac_c" 1>&6 +-echo "configure:784: checking for mingw32 environment" >&5 ++echo "configure:773: checking for mingw32 environment" >&5 + if eval "test \"`echo '$''{'ac_cv_mingw32'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + cat > conftest.$ac_ext <&5; (eval $ac_compile) 2>&5; }; then ++if { (eval echo configure:785: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then + rm -rf conftest* + ac_cv_mingw32=yes + else +@@ -903,7 +892,7 @@ + fi + + echo $ac_n "checking host system type""... $ac_c" 1>&6 +-echo "configure:907: checking host system type" >&5 ++echo "configure:896: checking host system type" >&5 + + host_alias=$host + case "$host_alias" in +@@ -924,7 +913,7 @@ + echo "$ac_t""$host" 1>&6 + + echo $ac_n "checking target system type""... $ac_c" 1>&6 +-echo "configure:928: checking target system type" >&5 ++echo "configure:917: checking target system type" >&5 + + target_alias=$target + case "$target_alias" in +@@ -942,7 +931,7 @@ + echo "$ac_t""$target" 1>&6 + + echo $ac_n "checking build system type""... $ac_c" 1>&6 +-echo "configure:946: checking build system type" >&5 ++echo "configure:935: checking build system type" >&5 + + build_alias=$build + case "$build_alias" in +@@ -982,7 +971,7 @@ + + missing_dir=`cd $ac_aux_dir && pwd` + echo $ac_n "checking for working aclocal""... $ac_c" 1>&6 +-echo "configure:986: checking for working aclocal" >&5 ++echo "configure:975: checking for working aclocal" >&5 + # Run test in a subshell; some versions of sh will print an error if + # an executable is not found, even if stderr is redirected. + # Redirect stdin to placate older versions of autoconf. Sigh. +@@ -995,7 +984,7 @@ + fi + + echo $ac_n "checking for working autoconf""... $ac_c" 1>&6 +-echo "configure:999: checking for working autoconf" >&5 ++echo "configure:988: checking for working autoconf" >&5 + # Run test in a subshell; some versions of sh will print an error if + # an executable is not found, even if stderr is redirected. + # Redirect stdin to placate older versions of autoconf. Sigh. +@@ -1008,7 +997,7 @@ + fi + + echo $ac_n "checking for working automake""... $ac_c" 1>&6 +-echo "configure:1012: checking for working automake" >&5 ++echo "configure:1001: checking for working automake" >&5 + # Run test in a subshell; some versions of sh will print an error if + # an executable is not found, even if stderr is redirected. + # Redirect stdin to placate older versions of autoconf. Sigh. +@@ -1021,7 +1010,7 @@ + fi + + echo $ac_n "checking for working autoheader""... $ac_c" 1>&6 +-echo "configure:1025: checking for working autoheader" >&5 ++echo "configure:1014: checking for working autoheader" >&5 + # Run test in a subshell; some versions of sh will print an error if + # an executable is not found, even if stderr is redirected. + # Redirect stdin to placate older versions of autoconf. Sigh. +@@ -1034,7 +1023,7 @@ + fi + + echo $ac_n "checking for working makeinfo""... $ac_c" 1>&6 +-echo "configure:1038: checking for working makeinfo" >&5 ++echo "configure:1027: checking for working makeinfo" >&5 + # Run test in a subshell; some versions of sh will print an error if + # an executable is not found, even if stderr is redirected. + # Redirect stdin to placate older versions of autoconf. Sigh. +@@ -1060,7 +1049,7 @@ + # Extract the first word of "gcc", so it can be a program name with args. + set dummy gcc; ac_word=$2 + echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 +-echo "configure:1064: checking for $ac_word" >&5 ++echo "configure:1053: checking for $ac_word" >&5 + if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else +@@ -1090,7 +1079,7 @@ + # Extract the first word of "cc", so it can be a program name with args. + set dummy cc; ac_word=$2 + echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 +-echo "configure:1094: checking for $ac_word" >&5 ++echo "configure:1083: checking for $ac_word" >&5 + if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else +@@ -1139,7 +1128,7 @@ + fi + + echo $ac_n "checking whether we are using GNU C""... $ac_c" 1>&6 +-echo "configure:1143: checking whether we are using GNU C" >&5 ++echo "configure:1132: checking whether we are using GNU C" >&5 + if eval "test \"`echo '$''{'ac_cv_prog_gcc'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else +@@ -1148,7 +1137,7 @@ + yes; + #endif + EOF +-if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:1152: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then ++if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:1141: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then + ac_cv_prog_gcc=yes + else + ac_cv_prog_gcc=no +@@ -1163,7 +1152,7 @@ + ac_save_CFLAGS="$CFLAGS" + CFLAGS= + echo $ac_n "checking whether ${CC-cc} accepts -g""... $ac_c" 1>&6 +-echo "configure:1167: checking whether ${CC-cc} accepts -g" >&5 ++echo "configure:1156: checking whether ${CC-cc} accepts -g" >&5 + if eval "test \"`echo '$''{'ac_cv_prog_cc_g'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else +@@ -1200,7 +1189,7 @@ + # Extract the first word of "$ac_prog", so it can be a program name with args. + set dummy $ac_prog; ac_word=$2 + echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 +-echo "configure:1204: checking for $ac_word" >&5 ++echo "configure:1193: checking for $ac_word" >&5 + if eval "test \"`echo '$''{'ac_cv_prog_CXX'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else +@@ -1233,7 +1222,7 @@ + test -z "$CXX" && { echo "configure: error: no acceptable c++ found in \$PATH" 1>&2; exit 1; } + + echo $ac_n "checking whether we are using GNU C++""... $ac_c" 1>&6 +-echo "configure:1237: checking whether we are using GNU C++" >&5 ++echo "configure:1226: checking whether we are using GNU C++" >&5 + if eval "test \"`echo '$''{'ac_cv_prog_gxx'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else +@@ -1242,7 +1231,7 @@ + yes; + #endif + EOF +-if { ac_try='${CXX-g++} -E conftest.C'; { (eval echo configure:1246: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then ++if { ac_try='${CXX-g++} -E conftest.C'; { (eval echo configure:1235: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then + ac_cv_prog_gxx=yes + else + ac_cv_prog_gxx=no +@@ -1257,7 +1246,7 @@ + ac_save_CXXFLAGS="$CXXFLAGS" + CXXFLAGS= + echo $ac_n "checking whether ${CXX-g++} accepts -g""... $ac_c" 1>&6 +-echo "configure:1261: checking whether ${CXX-g++} accepts -g" >&5 ++echo "configure:1250: checking whether ${CXX-g++} accepts -g" >&5 + if eval "test \"`echo '$''{'ac_cv_prog_cxx_g'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else +@@ -1290,7 +1279,7 @@ + # NEWLIB_CONFIGURE, which doesn't work because that means that it will + # be run before AC_CANONICAL_HOST. + echo $ac_n "checking build system type""... $ac_c" 1>&6 +-echo "configure:1294: checking build system type" >&5 ++echo "configure:1283: checking build system type" >&5 + + build_alias=$build + case "$build_alias" in +@@ -1311,7 +1300,7 @@ + # Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args. + set dummy ${ac_tool_prefix}as; ac_word=$2 + echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 +-echo "configure:1315: checking for $ac_word" >&5 ++echo "configure:1304: checking for $ac_word" >&5 + if eval "test \"`echo '$''{'ac_cv_prog_AS'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else +@@ -1343,7 +1332,7 @@ + # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args. + set dummy ${ac_tool_prefix}ar; ac_word=$2 + echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 +-echo "configure:1347: checking for $ac_word" >&5 ++echo "configure:1336: checking for $ac_word" >&5 + if eval "test \"`echo '$''{'ac_cv_prog_AR'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else +@@ -1375,7 +1364,7 @@ + # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args. + set dummy ${ac_tool_prefix}ranlib; ac_word=$2 + echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 +-echo "configure:1379: checking for $ac_word" >&5 ++echo "configure:1368: checking for $ac_word" >&5 + if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else +@@ -1407,7 +1396,7 @@ + # Extract the first word of "ranlib", so it can be a program name with args. + set dummy ranlib; ac_word=$2 + echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 +-echo "configure:1411: checking for $ac_word" >&5 ++echo "configure:1400: checking for $ac_word" >&5 + if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else +@@ -1452,7 +1441,7 @@ + # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff" + # ./install, which can be erroneously created by make from ./install.sh. + echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6 +-echo "configure:1456: checking for a BSD compatible install" >&5 ++echo "configure:1445: checking for a BSD compatible install" >&5 + if test -z "$INSTALL"; then + if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +@@ -1506,7 +1495,7 @@ + + + echo $ac_n "checking whether to enable maintainer-specific portions of Makefiles""... $ac_c" 1>&6 +-echo "configure:1510: checking whether to enable maintainer-specific portions of Makefiles" >&5 ++echo "configure:1499: checking whether to enable maintainer-specific portions of Makefiles" >&5 + # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given. + if test "${enable_maintainer_mode+set}" = set; then + enableval="$enable_maintainer_mode" +@@ -1544,7 +1533,7 @@ + + + echo $ac_n "checking for executable suffix""... $ac_c" 1>&6 +-echo "configure:1548: checking for executable suffix" >&5 ++echo "configure:1537: checking for executable suffix" >&5 + if eval "test \"`echo '$''{'ac_cv_exeext'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else +@@ -1554,10 +1543,10 @@ + rm -f conftest* + echo 'int main () { return 0; }' > conftest.$ac_ext + ac_cv_exeext= +- if { (eval echo configure:1558: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then ++ if { (eval echo configure:1547: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then + for file in conftest.*; do + case $file in +- *.c | *.o | *.obj | *.ilk | *.pdb) ;; ++ *.c | *.o | *.obj) ;; + *) ac_cv_exeext=`echo $file | sed -e s/conftest//` ;; + esac + done +@@ -1676,7 +1665,7 @@ + if test "$GCC" = yes; then + # Check if gcc -print-prog-name=ld gives a path. + echo $ac_n "checking for ld used by GCC""... $ac_c" 1>&6 +-echo "configure:1680: checking for ld used by GCC" >&5 ++echo "configure:1669: checking for ld used by GCC" >&5 + case $host in + *-*-mingw*) + # gcc leaves a trailing carriage return which upsets mingw +@@ -1706,10 +1695,10 @@ + esac + elif test "$with_gnu_ld" = yes; then + echo $ac_n "checking for GNU ld""... $ac_c" 1>&6 +-echo "configure:1710: checking for GNU ld" >&5 ++echo "configure:1699: checking for GNU ld" >&5 + else + echo $ac_n "checking for non-GNU ld""... $ac_c" 1>&6 +-echo "configure:1713: checking for non-GNU ld" >&5 ++echo "configure:1702: checking for non-GNU ld" >&5 + fi + if eval "test \"`echo '$''{'lt_cv_path_LD'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +@@ -1744,7 +1733,7 @@ + fi + test -z "$LD" && { echo "configure: error: no acceptable ld found in \$PATH" 1>&2; exit 1; } + echo $ac_n "checking if the linker ($LD) is GNU ld""... $ac_c" 1>&6 +-echo "configure:1748: checking if the linker ($LD) is GNU ld" >&5 ++echo "configure:1737: checking if the linker ($LD) is GNU ld" >&5 + if eval "test \"`echo '$''{'lt_cv_prog_gnu_ld'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else +@@ -1761,7 +1750,7 @@ + + + echo $ac_n "checking for $LD option to reload object files""... $ac_c" 1>&6 +-echo "configure:1765: checking for $LD option to reload object files" >&5 ++echo "configure:1754: checking for $LD option to reload object files" >&5 + if eval "test \"`echo '$''{'lt_cv_ld_reload_flag'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else +@@ -1773,7 +1762,7 @@ + test -n "$reload_flag" && reload_flag=" $reload_flag" + + echo $ac_n "checking for BSD-compatible nm""... $ac_c" 1>&6 +-echo "configure:1777: checking for BSD-compatible nm" >&5 ++echo "configure:1766: checking for BSD-compatible nm" >&5 + if eval "test \"`echo '$''{'lt_cv_path_NM'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else +@@ -1811,7 +1800,7 @@ + echo "$ac_t""$NM" 1>&6 + + echo $ac_n "checking whether ln -s works""... $ac_c" 1>&6 +-echo "configure:1815: checking whether ln -s works" >&5 ++echo "configure:1804: checking whether ln -s works" >&5 + if eval "test \"`echo '$''{'ac_cv_prog_LN_S'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else +@@ -1832,7 +1821,7 @@ + fi + + echo $ac_n "checking how to recognise dependant libraries""... $ac_c" 1>&6 +-echo "configure:1836: checking how to recognise dependant libraries" >&5 ++echo "configure:1825: checking how to recognise dependant libraries" >&5 + if eval "test \"`echo '$''{'lt_cv_deplibs_check_method'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else +@@ -2005,13 +1994,13 @@ + deplibs_check_method=$lt_cv_deplibs_check_method + + echo $ac_n "checking for object suffix""... $ac_c" 1>&6 +-echo "configure:2009: checking for object suffix" >&5 ++echo "configure:1998: checking for object suffix" >&5 + if eval "test \"`echo '$''{'ac_cv_objext'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else + rm -f conftest* + echo 'int i = 1;' > conftest.$ac_ext +-if { (eval echo configure:2015: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then ++if { (eval echo configure:2004: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then + for ac_file in conftest.*; do + case $ac_file in + *.c) ;; +@@ -2035,7 +2024,7 @@ + file_magic*) + if test "$file_magic_cmd" = '$MAGIC_CMD'; then + echo $ac_n "checking for ${ac_tool_prefix}file""... $ac_c" 1>&6 +-echo "configure:2039: checking for ${ac_tool_prefix}file" >&5 ++echo "configure:2028: checking for ${ac_tool_prefix}file" >&5 + if eval "test \"`echo '$''{'lt_cv_path_MAGIC_CMD'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else +@@ -2097,7 +2086,7 @@ + if test -z "$lt_cv_path_MAGIC_CMD"; then + if test -n "$ac_tool_prefix"; then + echo $ac_n "checking for file""... $ac_c" 1>&6 +-echo "configure:2101: checking for file" >&5 ++echo "configure:2090: checking for file" >&5 + if eval "test \"`echo '$''{'lt_cv_path_MAGIC_CMD'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else +@@ -2168,7 +2157,7 @@ + # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args. + set dummy ${ac_tool_prefix}ranlib; ac_word=$2 + echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 +-echo "configure:2172: checking for $ac_word" >&5 ++echo "configure:2161: checking for $ac_word" >&5 + if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else +@@ -2200,7 +2189,7 @@ + # Extract the first word of "ranlib", so it can be a program name with args. + set dummy ranlib; ac_word=$2 + echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 +-echo "configure:2204: checking for $ac_word" >&5 ++echo "configure:2193: checking for $ac_word" >&5 + if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else +@@ -2235,7 +2224,7 @@ + # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args. + set dummy ${ac_tool_prefix}strip; ac_word=$2 + echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 +-echo "configure:2239: checking for $ac_word" >&5 ++echo "configure:2228: checking for $ac_word" >&5 + if eval "test \"`echo '$''{'ac_cv_prog_STRIP'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else +@@ -2267,7 +2256,7 @@ + # Extract the first word of "strip", so it can be a program name with args. + set dummy strip; ac_word=$2 + echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 +-echo "configure:2271: checking for $ac_word" >&5 ++echo "configure:2260: checking for $ac_word" >&5 + if eval "test \"`echo '$''{'ac_cv_prog_STRIP'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else +@@ -2334,21 +2323,8 @@ + case $host in + *-*-irix6*) + # Find out which ABI we are using. +- echo '#line 2338 "configure"' > conftest.$ac_ext +- if { (eval echo configure:2339: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then +- if test "$lt_cv_prog_gnu_ld" = yes; then +- case `/usr/bin/file conftest.$ac_objext` in +- *32-bit*) +- LD="${LD-ld} -melf32bsmip" +- ;; +- *N32*) +- LD="${LD-ld} -melf32bmipn32" +- ;; +- *64-bit*) +- LD="${LD-ld} -melf64bmip" +- ;; +- esac +- else ++ echo '#line 2327 "configure"' > conftest.$ac_ext ++ if { (eval echo configure:2328: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then + case `/usr/bin/file conftest.$ac_objext` in + *32-bit*) + LD="${LD-ld} -32" +@@ -2361,14 +2337,13 @@ + ;; + esac + fi +- fi + rm -rf conftest* + ;; + + ia64-*-hpux*) + # Find out which ABI we are using. + echo 'int i;' > conftest.$ac_ext +- if { (eval echo configure:2372: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then ++ if { (eval echo configure:2347: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then + case "`/usr/bin/file conftest.o`" in + *ELF-32*) + HPUX_IA64_MODE="32" +@@ -2384,7 +2359,7 @@ + x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*|s390*-*linux*|sparc*-*linux*) + # Find out which ABI we are using. + echo 'int i;' > conftest.$ac_ext +- if { (eval echo configure:2388: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then ++ if { (eval echo configure:2363: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then + case "`/usr/bin/file conftest.o`" in + *32-bit*) + case $host in +@@ -2428,7 +2403,7 @@ + SAVE_CFLAGS="$CFLAGS" + CFLAGS="$CFLAGS -belf" + echo $ac_n "checking whether the C compiler needs -belf""... $ac_c" 1>&6 +-echo "configure:2432: checking whether the C compiler needs -belf" >&5 ++echo "configure:2407: checking whether the C compiler needs -belf" >&5 + if eval "test \"`echo '$''{'lt_cv_cc_needs_belf'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else +@@ -2441,14 +2416,14 @@ + cross_compiling=$ac_cv_prog_cc_cross + + cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then ++if { (eval echo configure:2427: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then + rm -rf conftest* + lt_cv_cc_needs_belf=yes + else +@@ -2478,7 +2453,7 @@ + esac + + echo $ac_n "checking how to run the C++ preprocessor""... $ac_c" 1>&6 +-echo "configure:2482: checking how to run the C++ preprocessor" >&5 ++echo "configure:2457: checking how to run the C++ preprocessor" >&5 + if test -z "$CXXCPP"; then + if eval "test \"`echo '$''{'ac_cv_prog_CXXCPP'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +@@ -2491,12 +2466,12 @@ + cross_compiling=$ac_cv_prog_cxx_cross + CXXCPP="${CXX-g++} -E" + cat > conftest.$ac_ext < + EOF + ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" +-{ (eval echo configure:2500: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } ++{ (eval echo configure:2475: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } + ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` + if test -z "$ac_err"; then + : +@@ -2643,7 +2618,7 @@ + + + echo $ac_n "checking whether to enable maintainer-specific portions of Makefiles""... $ac_c" 1>&6 +-echo "configure:2647: checking whether to enable maintainer-specific portions of Makefiles" >&5 ++echo "configure:2622: checking whether to enable maintainer-specific portions of Makefiles" >&5 + # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given. + if test "${enable_maintainer_mode+set}" = set; then + enableval="$enable_maintainer_mode" +@@ -2676,7 +2651,7 @@ + + + echo $ac_n "checking for executable suffix""... $ac_c" 1>&6 +-echo "configure:2680: checking for executable suffix" >&5 ++echo "configure:2655: checking for executable suffix" >&5 + if eval "test \"`echo '$''{'ac_cv_exeext'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 + else +@@ -2686,10 +2661,10 @@ + rm -f conftest* + echo 'int main () { return 0; }' > conftest.$ac_ext + ac_cv_exeext= +- if { (eval echo configure:2690: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then ++ if { (eval echo configure:2665: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then + for file in conftest.*; do + case $file in +- *.c | *.o | *.obj | *.ilk | *.pdb) ;; ++ *.c | *.o | *.obj) ;; + *) ac_cv_exeext=`echo $file | sed -e s/conftest//` ;; + esac + done +@@ -2709,7 +2684,7 @@ + fi + + echo $ac_n "checking for thread model used by GCC""... $ac_c" 1>&6 +-echo "configure:2713: checking for thread model used by GCC" >&5 ++echo "configure:2688: checking for thread model used by GCC" >&5 + THREADS=`$CC -v 2>&1 | sed -n 's/^Thread model: //p'` + if test -z "$THREADS"; then + THREADS=no +@@ -2818,6 +2793,22 @@ + *-*-cygwin*) + THREADLIBS= + ;; ++ *-*-darwin*) ++ cat >> confdefs.h <<\EOF ++#define GC_DARWIN_THREADS 1 ++EOF ++ ++ cat >> confdefs.h <<\EOF ++#define THREAD_LOCAL_ALLOC 1 ++EOF ++ ++ if test "${enable_parallel_mark}" = yes; then ++ cat >> confdefs.h <<\EOF ++#define PARALLEL_MARK 1 ++EOF ++ ++ fi ++ ;; + esac + ;; + win32) +@@ -2829,12 +2820,6 @@ + #define NO_GETENV 1 + EOF + +- if test $enable_shared = yes; then +- cat >> confdefs.h <<\EOF +-#define GC_DLL 1 +-EOF +- +- fi + ;; + decosf1 | irix | mach | os2 | solaris | dce | vxworks) + { echo "configure: error: thread package $THREADS not yet supported" 1>&2; exit 1; } +@@ -2845,8 +2830,28 @@ + esac + + +-echo $ac_n "checking for dlopen in -ldl""... $ac_c" 1>&6 +-echo "configure:2850: checking for dlopen in -ldl" >&5 ++case "$host" in ++ powerpc-*-darwin*) ++ powerpc_darwin=true ++ ;; ++esac ++ ++ ++if test x$powerpc_darwin = xtrue; then ++ POWERPC_DARWIN_TRUE= ++ POWERPC_DARWIN_FALSE='#' ++else ++ POWERPC_DARWIN_TRUE='#' ++ POWERPC_DARWIN_FALSE= ++fi ++ ++# We never want libdl on darwin. It is a fake libdl that just ends up making ++# dyld calls anyway ++case "$host" in ++ *-*-darwin*) ;; ++ *) ++ echo $ac_n "checking for dlopen in -ldl""... $ac_c" 1>&6 ++echo "configure:2855: checking for dlopen in -ldl" >&5 + ac_lib_var=`echo dl'_'dlopen | sed 'y%./+-%__p_%'` + if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +@@ -2854,7 +2859,7 @@ + ac_save_LIBS="$LIBS" + LIBS="-ldl $LIBS" + cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then ++if { (eval echo configure:2874: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then + rm -rf conftest* + eval "ac_cv_lib_$ac_lib_var=yes" + else +@@ -2885,6 +2890,9 @@ + echo "$ac_t""no" 1>&6 + fi + ++ ;; ++esac ++ + + + target_all=libgcjgc.la +@@ -3100,17 +3108,15 @@ + fi + + +-if test -n "$with_cross_host" && +- test x"$with_cross_host" != x"no"; then +- toolexecdir='$(exec_prefix)/$(target_alias)' +- toolexeclibdir='$(toolexecdir)/lib' +-else +- toolexecdir='$(libdir)/gcc-lib/$(target_alias)' +- toolexeclibdir='$(libdir)' +-fi +-toolexeclibdir=$toolexeclibdir/`$CC -print-multi-os-directory` + + ++if test -z "$with_cross_host"; then ++ USE_LIBDIR_TRUE= ++ USE_LIBDIR_FALSE='#' ++else ++ USE_LIBDIR_TRUE='#' ++ USE_LIBDIR_FALSE= ++fi + + if test "${multilib}" = "yes"; then + multilib_arg="--enable-multilib" +@@ -3307,14 +3313,16 @@ + s%@LIBTOOL@%$LIBTOOL%g + s%@CXXCPP@%$CXXCPP%g + s%@THREADLIBS@%$THREADLIBS%g ++s%@POWERPC_DARWIN_TRUE@%$POWERPC_DARWIN_TRUE%g ++s%@POWERPC_DARWIN_FALSE@%$POWERPC_DARWIN_FALSE%g + s%@EXTRA_TEST_LIBS@%$EXTRA_TEST_LIBS%g + s%@target_all@%$target_all%g + s%@INCLUDES@%$INCLUDES%g + s%@CXXINCLUDES@%$CXXINCLUDES%g + s%@addobjs@%$addobjs%g + s%@MY_CFLAGS@%$MY_CFLAGS%g +-s%@toolexecdir@%$toolexecdir%g +-s%@toolexeclibdir@%$toolexeclibdir%g ++s%@USE_LIBDIR_TRUE@%$USE_LIBDIR_TRUE%g ++s%@USE_LIBDIR_FALSE@%$USE_LIBDIR_FALSE%g + + CEOF + EOF +@@ -3323,7 +3331,7 @@ + + # Split the substitutions into bite-sized pieces for seds with + # small command number limits, like on Digital OSF/1 and HP-UX. +-ac_max_sed_cmds=60 # Maximum number of lines to put in a sed script. ++ac_max_sed_cmds=90 # Maximum number of lines to put in a sed script. + ac_file=1 # Number of current file. + ac_beg=1 # First line for current file. + ac_end=$ac_max_sed_cmds # Line after last line for current file. +@@ -3425,7 +3433,6 @@ + CONFIG_SHELL=${CONFIG_SHELL-/bin/sh} + gc_basedir=${gc_basedir} + CC="${CC}" +-ORIGINAL_LD_FOR_MULTILIBS="${ORIGINAL_LD_FOR_MULTILIBS}" + DEFS="$DEFS" + + EOF +diff -urNb boehm-gc/configure.in boehm-gc/configure.in +--- boehm-gc/configure.in Mon Apr 28 13:55:07 2003 ++++ boehm-gc/configure.in Mon May 26 13:33:22 2003 +@@ -1,4 +1,4 @@ +-# Copyright (c) 1999, 2000, 2001, 2002, 2003 by Red Hat, Inc. All rights reserved. ++# Copyright (c) 1999, 2000, 2001, 2002 by Red Hat, Inc. All rights reserved. + # + # THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED + # OR IMPLIED. ANY USE IS AT YOUR OWN RISK. +@@ -111,14 +111,18 @@ + *-*-cygwin*) + THREADLIBS= + ;; ++ *-*-darwin*) ++ AC_DEFINE(GC_DARWIN_THREADS) ++ AC_DEFINE(THREAD_LOCAL_ALLOC) ++ if test "${enable_parallel_mark}" = yes; then ++ AC_DEFINE(PARALLEL_MARK) ++ fi ++ ;; + esac + ;; + win32) + AC_DEFINE(GC_WIN32_THREADS) + AC_DEFINE(NO_GETENV) +- if test $enable_shared = yes; then +- AC_DEFINE(GC_DLL) +- fi + ;; + decosf1 | irix | mach | os2 | solaris | dce | vxworks) + AC_MSG_ERROR(thread package $THREADS not yet supported) +@@ -129,7 +133,22 @@ + esac + AC_SUBST(THREADLIBS) + +-AC_CHECK_LIB(dl, dlopen, EXTRA_TEST_LIBS="$EXTRA_TEST_LIBS -ldl") ++case "$host" in ++ powerpc-*-darwin*) ++ powerpc_darwin=true ++ ;; ++esac ++AM_CONDITIONAL(POWERPC_DARWIN,test x$powerpc_darwin = xtrue) ++ ++# We never want libdl on darwin. It is a fake libdl that just ends up making ++# dyld calls anyway ++case "$host" in ++ *-*-darwin*) ;; ++ *) ++ AC_CHECK_LIB(dl, dlopen, EXTRA_TEST_LIBS="$EXTRA_TEST_LIBS -ldl") ++ ;; ++esac ++ + AC_SUBST(EXTRA_TEST_LIBS) + + target_all=libgcjgc.la +@@ -270,17 +289,7 @@ + esac ] + fi) + +-if test -n "$with_cross_host" && +- test x"$with_cross_host" != x"no"; then +- toolexecdir='$(exec_prefix)/$(target_alias)' +- toolexeclibdir='$(toolexecdir)/lib' +-else +- toolexecdir='$(libdir)/gcc-lib/$(target_alias)' +- toolexeclibdir='$(libdir)' +-fi +-toolexeclibdir=$toolexeclibdir/`$CC -print-multi-os-directory` +-AC_SUBST(toolexecdir) +-AC_SUBST(toolexeclibdir) ++AM_CONDITIONAL(USE_LIBDIR, test -z "$with_cross_host") + + if test "${multilib}" = "yes"; then + multilib_arg="--enable-multilib" +@@ -304,6 +313,5 @@ + CONFIG_SHELL=${CONFIG_SHELL-/bin/sh} + gc_basedir=${gc_basedir} + CC="${CC}" +-ORIGINAL_LD_FOR_MULTILIBS="${ORIGINAL_LD_FOR_MULTILIBS}" + DEFS="$DEFS" + ) +diff -urNb boehm-gc/configure.in~ boehm-gc/configure.in~ +--- boehm-gc/configure.in~ Wed Dec 31 16:00:00 1969 ++++ boehm-gc/configure.in~ Mon May 26 13:33:22 2003 +@@ -0,0 +1,317 @@ ++# Copyright (c) 1999, 2000, 2001, 2002 by Red Hat, Inc. All rights reserved. ++# ++# THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED ++# OR IMPLIED. ANY USE IS AT YOUR OWN RISK. ++# ++# Permission is hereby granted to use or copy this program ++# for any purpose, provided the above notices are retained on all copies. ++# Permission to modify the code and to distribute modified code is granted, ++# provided the above notices are retained, and a notice that the code was ++# modified is included with the above copyright notice. ++# ++# Original author: Tom Tromey ++ ++dnl Process this file with autoconf to produce configure. ++ ++AC_INIT(gcj_mlc.c) ++ ++# This works around the fact that libtool configuration may change LD ++# for this particular configuration, but some shells, instead of ++# keeping the changes in LD private, export them just because LD is ++# exported. ++ORIGINAL_LD_FOR_MULTILIBS=$LD ++ ++dnl Can't be done in GC_CONFIGURE because that confuses automake. ++AC_CONFIG_AUX_DIR(.) ++ ++GC_CONFIGURE(.) ++ ++AM_PROG_LIBTOOL ++ ++dnl We use these options to decide which functions to include. ++AC_ARG_WITH(target-subdir, ++[ --with-target-subdir=SUBDIR ++ configuring with a cross compiler]) ++AC_ARG_WITH(cross-host, ++[ --with-cross-host=HOST configuring with a cross compiler]) ++ ++AM_MAINTAINER_MODE ++# automake wants to see AC_EXEEXT. But we don't need it. And having ++# it is actually a problem, because the compiler we're passed can't ++# necessarily do a full link. So we fool automake here. ++if false; then ++ # autoconf 2.50 runs AC_EXEEXT by default, and the macro expands ++ # to nothing, so nothing would remain between `then' and `fi' if it ++ # were not for the `:' below. ++ : ++ AC_EXEEXT ++fi ++ ++AC_MSG_CHECKING([for thread model used by GCC]) ++THREADS=`$CC -v 2>&1 | sed -n 's/^Thread model: //p'` ++if test -z "$THREADS"; then ++ THREADS=no ++fi ++AC_MSG_RESULT([$THREADS]) ++ ++AC_ARG_ENABLE(parallel-mark, ++[ --enable-parallel-mark parallelize marking and free list construction], ++ [case "$THREADS" in ++ no | none | single) ++ AC_MSG_ERROR([Parallel mark requires --enable-threads=x spec]) ++ ;; ++ esac] ++) ++ ++INCLUDES=-I${srcdir}/include ++THREADLIBS= ++case "$THREADS" in ++ no | none | single) ++ THREADS=none ++ ;; ++ posix | pthreads) ++ THREADS=posix ++ THREADLIBS=-lpthread ++ case "$host" in ++ x86-*-linux* | ia64-*-linux* | i586-*-linux* | i686-*-linux* | x86_64-*-linux* ) ++ AC_DEFINE(GC_LINUX_THREADS) ++ AC_DEFINE(_REENTRANT) ++ if test "${enable_parallel_mark}"; then ++ AC_DEFINE(PARALLEL_MARK) ++ fi ++ AC_DEFINE(THREAD_LOCAL_ALLOC) ++ ;; ++ *-*-linux*) ++ AC_DEFINE(GC_LINUX_THREADS) ++ AC_DEFINE(_REENTRANT) ++ ;; ++ *-*-hpux*) ++ AC_MSG_WARN("Only HP/UX 11 threads are supported.") ++ AC_DEFINE(GC_HPUX_THREADS) ++ AC_DEFINE(_POSIX_C_SOURCE,199506L) ++ if test "${enable_parallel_mark}" = yes; then ++ AC_DEFINE(PARALLEL_MARK) ++ fi ++ AC_DEFINE(THREAD_LOCAL_ALLOC) ++ THREADLIBS="-lpthread -lrt" ++ ;; ++ *-*-freebsd*) ++ AC_MSG_WARN("FreeBSD does not yet fully support threads with Boehm GC.") ++ AC_DEFINE(GC_FREEBSD_THREADS) ++ INCLUDES="$INCLUDES -pthread" ++ THREADLIBS=-pthread ++ ;; ++ *-*-solaris*) ++ AC_DEFINE(GC_SOLARIS_THREADS) ++ AC_DEFINE(GC_SOLARIS_PTHREADS) ++ ;; ++ *-*-irix*) ++ AC_DEFINE(GC_IRIX_THREADS) ++ ;; ++ *-*-cygwin*) ++ THREADLIBS= ++ ;; ++ esac ++ ;; ++ *-*-darwin*) ++ AC_DEFINE(GC_DARWIN_THREADS) ++ AC_DEFINE(THREAD_LOCAL_ALLOC) ++ if test "${enable_parallel_mark}" = yes; then ++ AC_DEFINE(PARALLEL_MARK) ++ fi ++ ;; ++ win32) ++ AC_DEFINE(GC_WIN32_THREADS) ++ AC_DEFINE(NO_GETENV) ++ ;; ++ decosf1 | irix | mach | os2 | solaris | dce | vxworks) ++ AC_MSG_ERROR(thread package $THREADS not yet supported) ++ ;; ++ *) ++ AC_MSG_ERROR($THREADS is an unknown thread package) ++ ;; ++esac ++AC_SUBST(THREADLIBS) ++ ++case "$host" in ++ powerpc-*-darwin*) ++ powerpc_darwin=true ++ ;; ++esac ++AM_CONDITIONAL(POWERPC_DARWIN,test x$powerpc_darwin = xtrue) ++ ++# We never want libdl on darwin. It is a fake libdl that just ends up making ++# dyld calls anyway ++case "$host" in ++ *-*-darwin*) ;; ++ *) ++ AC_CHECK_LIB(dl, dlopen, EXTRA_TEST_LIBS="$EXTRA_TEST_LIBS -ldl") ++ ;; ++esac ++ ++AC_SUBST(EXTRA_TEST_LIBS) ++ ++target_all=libgcjgc.la ++AC_SUBST(target_all) ++AC_SUBST(target_alias) ++ ++dnl If the target is an eCos system, use the appropriate eCos ++dnl I/O routines. ++dnl FIXME: this should not be a local option but a global target ++dnl system; at present there is no eCos target. ++TARGET_ECOS="no" ++AC_ARG_WITH(ecos, ++[ --with-ecos enable runtime eCos target support], ++TARGET_ECOS="$with_ecos" ++) ++ ++addobjs= ++CXXINCLUDES= ++case "$TARGET_ECOS" in ++ no) ++ ;; ++ *) ++ AC_DEFINE(ECOS) ++ CXXINCLUDES="-I${TARGET_ECOS}/include" ++ addobjs="$addobjs ecos.lo" ++ ;; ++esac ++AC_SUBST(CXX) ++ ++AC_SUBST(INCLUDES) ++AC_SUBST(CXXINCLUDES) ++ ++machdep= ++case "$host" in ++ alpha*-*-openbsd*) ++ machdep="alpha_mach_dep.lo" ++ if test x"${ac_cv_lib_dl_dlopen}" != xyes ; then ++ AC_MSG_WARN(OpenBSD/Alpha without dlopen(). Shared library support is disabled) ++ AM_DISABLE_SHARED ++ fi ++ ;; ++ alpha*-*-*) ++ machdep="alpha_mach_dep.lo" ++ ;; ++ i?86-*-solaris2.[[89]]*) ++ AC_DEFINE(SOLARIS25_PROC_VDB_BUG_FIXED) ++ ;; ++ mipstx39-*-elf*) ++ machdep="mips_ultrix_mach_dep.lo" ++ AC_DEFINE(STACKBASE, __stackbase) ++ AC_DEFINE(DATASTART_IS_ETEXT) ++ ;; ++ mips-dec-ultrix*) ++ machdep="mips_ultrix_mach-dep.lo" ++ ;; ++ mips*-*-linux*) ++ ;; ++ mips-*-*) ++ machdep="mips_sgi_mach_dep.lo" ++ AC_DEFINE(NO_EXECUTE_PERMISSION) ++ ;; ++ sparc-sun-solaris2.3*) ++ machdep="sparc_mach_dep.lo" ++ AC_DEFINE(SUNOS53_SHARED_LIB) ++ ;; ++ sparc-sun-solaris2.*) ++ machdep="sparc_mach_dep.lo" ++ ;; ++ ia64-*-*) ++ machdep="mach_dep.lo ia64_save_regs_in_stack.lo" ++ ;; ++esac ++if test x"$machdep" = x; then ++ machdep="mach_dep.lo" ++fi ++addobjs="$addobjs $machdep" ++AC_SUBST(addobjs) ++ ++dnl As of 4.13a2, the collector will not properly work on Solaris when ++dnl built with gcc and -O. So we remove -O in the appropriate case. ++case "$host" in ++ sparc-sun-solaris2*) ++ if test "$GCC" = yes; then ++ new_CFLAGS= ++ for i in $CFLAGS; do ++ case "$i" in ++ -O*) ++ ;; ++ *) ++ new_CFLAGS="$new_CFLAGS $i" ++ ;; ++ esac ++ done ++ CFLAGS="$new_CFLAGS" ++ fi ++ ;; ++esac ++ ++dnl We need to override the top-level CFLAGS. This is how we do it. ++MY_CFLAGS="$CFLAGS" ++AC_SUBST(MY_CFLAGS) ++ ++dnl Include defines that have become de facto standard. ++dnl ALL_INTERIOR_POINTERS can be overridden in startup code. ++AC_DEFINE(SILENT) ++AC_DEFINE(NO_SIGNALS) ++AC_DEFINE(NO_EXECUTE_PERMISSION) ++AC_DEFINE(ALL_INTERIOR_POINTERS) ++ ++dnl By default, make the library as general as possible. ++AC_DEFINE(JAVA_FINALIZATION) ++AC_DEFINE(GC_GCJ_SUPPORT) ++AC_DEFINE(ATOMIC_UNCOLLECTABLE) ++ ++dnl This is something of a hack. When cross-compiling we turn off ++dnl some functionality. These is only correct when targetting an ++dnl embedded system. FIXME. ++if test -n "${with_cross_host}"; then ++ AC_DEFINE(NO_SIGSET) ++ AC_DEFINE(NO_DEBUGGING) ++fi ++ ++AC_ARG_ENABLE(full-debug, ++[ --enable-full-debug include full support for pointer backtracing etc.], ++[ if test "$enable_full_debug" = "yes"; then ++ AC_MSG_WARN("Must define GC_DEBUG and use debug alloc. in clients.") ++ AC_DEFINE(KEEP_BACK_PTRS) ++ AC_DEFINE(DBG_HDRS_ALL) ++ case $host in ++ ia64-*-linux* ) ++ AC_DEFINE(MAKE_BACK_GRAPH) ++ ;; ++ x86-*-linux* | i586-*-linux* | i686-*-linux* | x86_64-*-linux* ) ++ AC_DEFINE(MAKE_BACK_GRAPH) ++ AC_MSG_WARN("Client must not use -fomit-frame-pointer.") ++ AC_DEFINE(SAVE_CALL_COUNT, 8) ++ ;; ++ esac ] ++ fi) ++ ++AM_CONDITIONAL(USE_LIBDIR, test -z "$with_cross_host") ++ ++if test "${multilib}" = "yes"; then ++ multilib_arg="--enable-multilib" ++else ++ multilib_arg= ++fi ++ ++AC_OUTPUT(Makefile include/Makefile, [ ++dnl Put all the -D options in a file. ++echo "$DEFS" > boehm-cflags ++ ++if test -n "$CONFIG_FILES"; then ++ LD="${ORIGINAL_LD_FOR_MULTILIBS}" ++ ac_file=Makefile . ${gc_basedir}/../config-ml.in ++fi], ++srcdir=${srcdir} ++host=${host} ++target=${target} ++with_multisubdir=${with_multisubdir} ++ac_configure_args="${multilib_arg} ${ac_configure_args}" ++CONFIG_SHELL=${CONFIG_SHELL-/bin/sh} ++gc_basedir=${gc_basedir} ++CC="${CC}" ++DEFS="$DEFS" ++) +diff -urNb boehm-gc/darwin_stop_world.c boehm-gc/darwin_stop_world.c +--- boehm-gc/darwin_stop_world.c Wed Dec 31 16:00:00 1969 ++++ boehm-gc/darwin_stop_world.c Sun Jun 1 14:17:58 2003 +@@ -0,0 +1,200 @@ ++#include "private/pthread_support.h" ++ ++# if defined(GC_DARWIN_THREADS) ++ ++#define DEBUG_THREADS 0 ++ ++/* From "Inside Mac OS X - Mach-O Runtime Architecture" published by Apple ++ Page 49: ++ "The space beneath the stack pointer, where a new stack frame would normally ++ be allocated, is called the red zone. This area as shown in Figure 3-2 may ++ be used for any purpose as long as a new stack frame does not need to be ++ added to the stack." ++ ++ Page 50: "If a leaf procedure's red zone usage would exceed 224 bytes, then ++ it must set up a stack frame just like routines that call other routines." ++*/ ++#define PPC_RED_ZONE_SIZE 224 ++ ++void GC_push_all_stacks() { ++ int i; ++ kern_return_t r; ++ GC_thread p; ++ pthread_t me; ++ ptr_t lo, hi; ++# if defined(POWERPC) ++ ppc_thread_state_t state; ++# else ++# error FIXME for non-ppc OS X ++# endif ++ mach_msg_type_number_t thread_state_count = MACHINE_THREAD_STATE_COUNT; ++ ++ me = pthread_self(); ++ if (!GC_thr_initialized) GC_thr_init(); ++ ++ for(i=0;inext) { ++ if(p -> flags & FINISHED) continue; ++ if(pthread_equal(p->id,me)) { ++ lo = GC_approx_sp(); ++ } else { ++ /* Get the thread state (registers, etc) */ ++ r = thread_get_state( ++ p->stop_info.mach_thread, ++ MACHINE_THREAD_STATE, ++ (natural_t*)&state, ++ &thread_state_count); ++ if(r != KERN_SUCCESS) ABORT("thread_get_state failed"); ++ ++ #ifdef POWERPC ++ lo = (void*)(state.r1 - PPC_RED_ZONE_SIZE); ++ ++ GC_push_one(state.r0); ++ GC_push_one(state.r2); ++ GC_push_one(state.r3); ++ GC_push_one(state.r4); ++ GC_push_one(state.r5); ++ GC_push_one(state.r6); ++ GC_push_one(state.r7); ++ GC_push_one(state.r8); ++ GC_push_one(state.r9); ++ GC_push_one(state.r10); ++ GC_push_one(state.r11); ++ GC_push_one(state.r12); ++ GC_push_one(state.r13); ++ GC_push_one(state.r14); ++ GC_push_one(state.r15); ++ GC_push_one(state.r16); ++ GC_push_one(state.r17); ++ GC_push_one(state.r18); ++ GC_push_one(state.r19); ++ GC_push_one(state.r20); ++ GC_push_one(state.r21); ++ GC_push_one(state.r22); ++ GC_push_one(state.r23); ++ GC_push_one(state.r24); ++ GC_push_one(state.r25); ++ GC_push_one(state.r26); ++ GC_push_one(state.r27); ++ GC_push_one(state.r28); ++ GC_push_one(state.r29); ++ GC_push_one(state.r30); ++ GC_push_one(state.r31); ++ #else ++ # error FIXME for non-PPC darwin ++ #endif /* !POWERPC */ ++ } /* p != me */ ++ if(p->flags & MAIN_THREAD) ++ hi = GC_stackbottom; ++ else ++ hi = p->stack_end; ++ #if DEBUG_THREADS ++ GC_printf3("Darwin: Stack for thread 0x%lx = [%lx,%lx)\n", ++ (unsigned long) p -> id, ++ (unsigned long) lo, ++ (unsigned long) hi ++ ); ++ #endif ++ GC_push_all_stack(lo,hi); ++ } /* for(p=GC_threads[i]...) */ ++ } /* for(i=0;i next) { ++ if (p -> id == my_thread) continue; ++ if (p -> flags & FINISHED) continue; ++ if (p -> thread_blocked) /* Will wait */ continue; ++ ++ #if DEBUG_THREADS ++ GC_printf1("Suspending thread 0x%lx\n", p -> id); ++ #endif ++ ++ /* Suspend the thread */ ++ kern_result = thread_suspend(p->stop_info.mach_thread); ++ if(kern_result != KERN_SUCCESS) ABORT("thread_suspend failed"); ++ } ++ } ++ ++# ifdef MPROTECT_VDB ++ if(GC_incremental) { ++ extern void GC_mprotect_stop(); ++ GC_mprotect_stop(); ++ } ++# endif ++ ++# ifdef PARALLEL_MARK ++ GC_release_mark_lock(); ++# endif ++ #if DEBUG_THREADS ++ GC_printf1("World stopped from 0x%lx\n", pthread_self()); ++ #endif ++} ++ ++/* Caller holds allocation lock, and has held it continuously since */ ++/* the world stopped. */ ++void GC_start_world() ++{ ++ pthread_t my_thread = pthread_self(); ++ int i; ++ GC_thread p; ++ kern_return_t kern_result; ++ ++# if DEBUG_THREADS ++ GC_printf0("World starting\n"); ++# endif ++ ++# ifdef MPROTECT_VDB ++ if(GC_incremental) { ++ extern void GC_mprotect_resume(); ++ GC_mprotect_resume(); ++ } ++# endif ++ ++ for (i = 0; i < THREAD_TABLE_SZ; i++) { ++ for (p = GC_threads[i]; p != 0; p = p -> next) { ++ if (p -> id == my_thread) continue; ++ if (p -> flags & FINISHED) continue; ++ if (p -> thread_blocked) continue; ++ ++ #if DEBUG_THREADS ++ GC_printf1("Resuming 0x%lx\n", p -> id); ++ #endif ++ ++ /* Resume the thread */ ++ kern_result = thread_resume(p->stop_info.mach_thread); ++ if(kern_result != KERN_SUCCESS) ABORT("thread_resume failed"); ++ } ++ } ++ #if DEBUG_THREADS ++ GC_printf0("World started\n"); ++ #endif ++} ++ ++void GC_stop_init() { ++ ++} ++ ++#endif +diff -urNb boehm-gc/dbg_mlc.c boehm-gc/dbg_mlc.c +--- boehm-gc/dbg_mlc.c Tue Feb 12 21:38:39 2002 ++++ boehm-gc/dbg_mlc.c Mon May 26 12:48:52 2003 +@@ -60,7 +60,7 @@ + # include + + # if defined(LINUX) || defined(SUNOS4) || defined(SUNOS5) \ +- || defined(HPUX) || defined(IRIX) || defined(OSF1) ++ || defined(HPUX) || defined(IRIX5) || defined(OSF1) + # define RANDOM() random() + # else + # define RANDOM() (long)rand() +@@ -228,6 +228,8 @@ + + #endif /* KEEP_BACK_PTRS */ + ++# define CROSSES_HBLK(p, sz) \ ++ (((word)(p + sizeof(oh) + sz - 1) ^ (word)p) >= HBLKSIZE) + /* Store debugging info into p. Return displaced pointer. */ + /* Assumes we don't hold allocation lock. */ + ptr_t GC_store_debug_info(p, sz, string, integer) +@@ -243,6 +245,8 @@ + /* But that's expensive. And this way things should only appear */ + /* inconsistent while we're in the handler. */ + LOCK(); ++ GC_ASSERT(GC_size(p) >= sizeof(oh) + sz); ++ GC_ASSERT(!(SMALL_OBJ(sz) && CROSSES_HBLK(p, sz))); + # ifdef KEEP_BACK_PTRS + ((oh *)p) -> oh_back_ptr = HIDE_BACK_PTR(NOT_MARKED); + # endif +@@ -275,6 +279,8 @@ + /* There is some argument that we should disable signals here. */ + /* But that's expensive. And this way things should only appear */ + /* inconsistent while we're in the handler. */ ++ GC_ASSERT(GC_size(p) >= sizeof(oh) + sz); ++ GC_ASSERT(!(SMALL_OBJ(sz) && CROSSES_HBLK(p, sz))); + # ifdef KEEP_BACK_PTRS + ((oh *)p) -> oh_back_ptr = HIDE_BACK_PTR(NOT_MARKED); + # endif +@@ -324,10 +330,11 @@ + { + register oh * ohdr = (oh *)GC_base(p); + ++ GC_ASSERT(!I_HOLD_LOCK()); + GC_err_printf1("0x%lx (", ((unsigned long)ohdr + sizeof(oh))); + GC_err_puts(ohdr -> oh_string); + # ifdef SHORT_DBG_HDRS +- GC_err_printf1(":%ld, sz=%ld)\n", (unsigned long)(ohdr -> oh_int)); ++ GC_err_printf1(":%ld)\n", (unsigned long)(ohdr -> oh_int)); + # else + GC_err_printf2(":%ld, sz=%ld)\n", (unsigned long)(ohdr -> oh_int), + (unsigned long)(ohdr -> oh_sz)); +@@ -342,6 +349,7 @@ + ptr_t p; + # endif + { ++ GC_ASSERT(!I_HOLD_LOCK()); + if (GC_HAS_DEBUG_INFO(p)) { + GC_print_obj(p); + } else { +@@ -355,6 +363,7 @@ + { + register oh * ohdr = (oh *)GC_base(p); + ++ GC_ASSERT(!I_HOLD_LOCK()); + GC_err_printf2("0x%lx in object at 0x%lx(", (unsigned long)clobbered_addr, + (unsigned long)p); + if (clobbered_addr <= (ptr_t)(&(ohdr -> oh_sz)) +@@ -376,14 +385,18 @@ + + void GC_check_heap_proc GC_PROTO((void)); + ++void GC_print_all_smashed_proc GC_PROTO((void)); ++ + void GC_do_nothing() {} + + void GC_start_debugging() + { + # ifndef SHORT_DBG_HDRS + GC_check_heap = GC_check_heap_proc; ++ GC_print_all_smashed = GC_print_all_smashed_proc; + # else + GC_check_heap = GC_do_nothing; ++ GC_print_all_smashed = GC_do_nothing; + # endif + GC_print_heap_obj = GC_debug_print_heap_obj_proc; + GC_debugging_started = TRUE; +@@ -429,6 +442,62 @@ + return (GC_store_debug_info(result, (word)lb, s, (word)i)); + } + ++# ifdef __STDC__ ++ GC_PTR GC_debug_malloc_ignore_off_page(size_t lb, GC_EXTRA_PARAMS) ++# else ++ GC_PTR GC_debug_malloc_ignore_off_page(lb, s, i) ++ size_t lb; ++ char * s; ++ int i; ++# ifdef GC_ADD_CALLER ++ --> GC_ADD_CALLER not implemented for K&R C ++# endif ++# endif ++{ ++ GC_PTR result = GC_malloc_ignore_off_page(lb + DEBUG_BYTES); ++ ++ if (result == 0) { ++ GC_err_printf1("GC_debug_malloc_ignore_off_page(%ld) returning NIL (", ++ (unsigned long) lb); ++ GC_err_puts(s); ++ GC_err_printf1(":%ld)\n", (unsigned long)i); ++ return(0); ++ } ++ if (!GC_debugging_started) { ++ GC_start_debugging(); ++ } ++ ADD_CALL_CHAIN(result, ra); ++ return (GC_store_debug_info(result, (word)lb, s, (word)i)); ++} ++ ++# ifdef __STDC__ ++ GC_PTR GC_debug_malloc_atomic_ignore_off_page(size_t lb, GC_EXTRA_PARAMS) ++# else ++ GC_PTR GC_debug_malloc_atomic_ignore_off_page(lb, s, i) ++ size_t lb; ++ char * s; ++ int i; ++# ifdef GC_ADD_CALLER ++ --> GC_ADD_CALLER not implemented for K&R C ++# endif ++# endif ++{ ++ GC_PTR result = GC_malloc_atomic_ignore_off_page(lb + DEBUG_BYTES); ++ ++ if (result == 0) { ++ GC_err_printf1("GC_debug_malloc_atomic_ignore_off_page(%ld)" ++ " returning NIL (", (unsigned long) lb); ++ GC_err_puts(s); ++ GC_err_printf1(":%ld)\n", (unsigned long)i); ++ return(0); ++ } ++ if (!GC_debugging_started) { ++ GC_start_debugging(); ++ } ++ ADD_CALL_CHAIN(result, ra); ++ return (GC_store_debug_info(result, (word)lb, s, (word)i)); ++} ++ + # ifdef DBG_HDRS_ALL + /* + * An allocation function for internal use. +@@ -447,7 +516,7 @@ + (unsigned long) lb); + return(0); + } +- ADD_CALL_CHAIN(result, ra); ++ ADD_CALL_CHAIN(result, GC_RETURN_ADDR); + return (GC_store_debug_info_inner(result, (word)lb, "INTERNAL", (word)0)); + } + +@@ -461,7 +530,7 @@ + (unsigned long) lb); + return(0); + } +- ADD_CALL_CHAIN(result, ra); ++ ADD_CALL_CHAIN(result, GC_RETURN_ADDR); + return (GC_store_debug_info_inner(result, (word)lb, "INTERNAL", (word)0)); + } + # endif +@@ -592,7 +661,7 @@ + int i; + # endif + { +- GC_PTR result = GC_malloc_uncollectable(lb + DEBUG_BYTES); ++ GC_PTR result = GC_malloc_uncollectable(lb + UNCOLLECTABLE_DEBUG_BYTES); + + if (result == 0) { + GC_err_printf1("GC_debug_malloc_uncollectable(%ld) returning NIL (", +@@ -618,7 +687,8 @@ + int i; + # endif + { +- GC_PTR result = GC_malloc_atomic_uncollectable(lb + DEBUG_BYTES); ++ GC_PTR result = ++ GC_malloc_atomic_uncollectable(lb + UNCOLLECTABLE_DEBUG_BYTES); + + if (result == 0) { + GC_err_printf1( +@@ -774,6 +844,45 @@ + } + + #ifndef SHORT_DBG_HDRS ++ ++/* List of smashed objects. We defer printing these, since we can't */ ++/* always print them nicely with the allocation lock held. */ ++/* We put them here instead of in GC_arrays, since it may be useful to */ ++/* be able to look at them with the debugger. */ ++#define MAX_SMASHED 20 ++ptr_t GC_smashed[MAX_SMASHED]; ++unsigned GC_n_smashed = 0; ++ ++# if defined(__STDC__) || defined(__cplusplus) ++ void GC_add_smashed(ptr_t smashed) ++# else ++ void GC_add_smashed(smashed) ++ ptr_t smashed; ++#endif ++{ ++ GC_ASSERT(GC_is_marked(GC_base(smashed))); ++ GC_smashed[GC_n_smashed] = smashed; ++ if (GC_n_smashed < MAX_SMASHED - 1) ++GC_n_smashed; ++ /* In case of overflow, we keep the first MAX_SMASHED-1 */ ++ /* entries plus the last one. */ ++ GC_have_errors = TRUE; ++} ++ ++/* Print all objects on the list. Clear the list. */ ++void GC_print_all_smashed_proc () ++{ ++ unsigned i; ++ ++ GC_ASSERT(!I_HOLD_LOCK()); ++ if (GC_n_smashed == 0) return; ++ GC_err_printf0("GC_check_heap_block: found smashed heap objects:\n"); ++ for (i = 0; i < GC_n_smashed; ++i) { ++ GC_print_smashed_obj(GC_base(GC_smashed[i]), GC_smashed[i]); ++ GC_smashed[i] = 0; ++ } ++ GC_n_smashed = 0; ++} ++ + /* Check all marked objects in the given block for validity */ + /*ARGSUSED*/ + # if defined(__STDC__) || defined(__cplusplus) +@@ -802,11 +911,7 @@ + && GC_HAS_DEBUG_INFO((ptr_t)p)) { + ptr_t clobbered = GC_check_annotated_obj((oh *)p); + +- if (clobbered != 0) { +- GC_err_printf0( +- "GC_check_heap_block: found smashed location at "); +- GC_print_smashed_obj((ptr_t)p, clobbered); +- } ++ if (clobbered != 0) GC_add_smashed(clobbered); + } + word_no += sz; + p += sz; +@@ -819,9 +924,11 @@ + void GC_check_heap_proc() + { + # ifndef SMALL_CONFIG +- if (sizeof(oh) & (2 * sizeof(word) - 1) != 0) { +- ABORT("Alignment problem: object header has inappropriate size\n"); +- } ++# ifdef ALIGN_DOUBLE ++ GC_STATIC_ASSERT((sizeof(oh) & (2 * sizeof(word) - 1)) == 0); ++# else ++ GC_STATIC_ASSERT((sizeof(oh) & (sizeof(word) - 1)) == 0); ++# endif + # endif + GC_apply_to_all_blocks(GC_check_heap_block, (word)0); + } +@@ -908,7 +1015,7 @@ + ptr_t base = GC_base(obj); + if (0 == base || (ptr_t)obj - base != sizeof(oh)) { + GC_err_printf1( +- "GC_register_finalizer called with non-base-pointer 0x%lx\n", ++ "GC_debug_register_finalizer called with non-base-pointer 0x%lx\n", + obj); + } + if (0 == fn) { +@@ -940,7 +1047,7 @@ + ptr_t base = GC_base(obj); + if (0 == base || (ptr_t)obj - base != sizeof(oh)) { + GC_err_printf1( +- "GC_register_finalizer_no_order called with non-base-pointer 0x%lx\n", ++ "GC_debug_register_finalizer_no_order called with non-base-pointer 0x%lx\n", + obj); + } + if (0 == fn) { +@@ -973,7 +1080,7 @@ + ptr_t base = GC_base(obj); + if (0 == base || (ptr_t)obj - base != sizeof(oh)) { + GC_err_printf1( +- "GC_register_finalizer_ignore_self called with non-base-pointer 0x%lx\n", ++ "GC_debug_register_finalizer_ignore_self called with non-base-pointer 0x%lx\n", + obj); + } + if (0 == fn) { +diff -urNb boehm-gc/dyn_load.c boehm-gc/dyn_load.c +--- boehm-gc/dyn_load.c Mon Mar 3 22:38:30 2003 ++++ boehm-gc/dyn_load.c Thu Sep 11 21:57:10 2003 +@@ -55,9 +55,10 @@ + !defined(MSWIN32) && !defined(MSWINCE) && \ + !(defined(ALPHA) && defined(OSF1)) && \ + !defined(HPUX) && !(defined(LINUX) && defined(__ELF__)) && \ +- !defined(RS6000) && !defined(SCO_ELF) && \ ++ !defined(RS6000) && !defined(SCO_ELF) && !defined(DGUX) && \ + !(defined(FREEBSD) && defined(__ELF__)) && \ +- !(defined(NETBSD) && defined(__ELF__)) && !defined(HURD) ++ !(defined(NETBSD) && defined(__ELF__)) && !defined(HURD) && \ ++ !defined(DARWIN) + --> We only know how to find data segments of dynamic libraries for the + --> above. Additional SVR4 variants might not be too + --> hard to add. +@@ -80,7 +81,7 @@ + #endif + + #if defined(LINUX) && defined(__ELF__) || defined(SCO_ELF) || \ +- (defined(FREEBSD) && defined(__ELF__)) || \ ++ (defined(FREEBSD) && defined(__ELF__)) || defined(DGUX) || \ + (defined(NETBSD) && defined(__ELF__)) || defined(HURD) + # include + # include +@@ -264,7 +265,7 @@ + # endif /* SUNOS */ + + #if defined(LINUX) && defined(__ELF__) || defined(SCO_ELF) || \ +- (defined(FREEBSD) && defined(__ELF__)) || \ ++ (defined(FREEBSD) && defined(__ELF__)) || defined(DGUX) || \ + (defined(NETBSD) && defined(__ELF__)) || defined(HURD) + + +@@ -282,56 +283,23 @@ + /* Repeatedly read until buffer is filled, or EOF is encountered */ + /* Defined in os_dep.c. */ + +-static char *parse_map_entry(char *buf_ptr, word *start, word *end, ++char *GC_parse_map_entry(char *buf_ptr, word *start, word *end, + char *prot_buf, unsigned int *maj_dev); ++word GC_apply_to_maps(word (*fn)(char *)); ++ /* From os_dep.c */ + +-void GC_register_dynamic_libraries() ++word GC_register_map_entries(char *maps) + { +- int f; +- int result; + char prot_buf[5]; +- int maps_size; +- char maps_temp[32768]; +- char *maps_buf; +- char *buf_ptr; ++ char *buf_ptr = maps; + int count; + word start, end; +- unsigned int maj_dev, min_dev; ++ unsigned int maj_dev; + word least_ha, greatest_ha; + unsigned i; + word datastart = (word)(DATASTART); + +- /* Read /proc/self/maps */ +- /* Note that we may not allocate, and thus can't use stdio. */ +- f = open("/proc/self/maps", O_RDONLY); +- if (-1 == f) ABORT("Couldn't open /proc/self/maps"); +- /* stat() doesn't work for /proc/self/maps, so we have to +- read it to find out how large it is... */ +- maps_size = 0; +- do { +- result = GC_repeat_read(f, maps_temp, sizeof(maps_temp)); +- if (result <= 0) ABORT("Couldn't read /proc/self/maps"); +- maps_size += result; +- } while (result == sizeof(maps_temp)); +- +- if (maps_size > sizeof(maps_temp)) { +- /* If larger than our buffer, close and re-read it. */ +- close(f); +- f = open("/proc/self/maps", O_RDONLY); +- if (-1 == f) ABORT("Couldn't open /proc/self/maps"); +- maps_buf = alloca(maps_size); +- if (NULL == maps_buf) ABORT("/proc/self/maps alloca failed"); +- result = GC_repeat_read(f, maps_buf, maps_size); +- if (result <= 0) ABORT("Couldn't read /proc/self/maps"); +- } else { +- /* Otherwise use the fixed size buffer */ +- maps_buf = maps_temp; +- } +- +- close(f); +- maps_buf[result] = '\0'; +- buf_ptr = maps_buf; +- /* Compute heap bounds. Should be done by add_to_heap? */ ++ /* Compute heap bounds. FIXME: Should be done by add_to_heap? */ + least_ha = (word)(-1); + greatest_ha = 0; + for (i = 0; i < GC_n_heap_sects; ++i) { +@@ -342,11 +310,10 @@ + } + if (greatest_ha < (word)GC_scratch_last_end_ptr) + greatest_ha = (word)GC_scratch_last_end_ptr; +- for (;;) { +- +- buf_ptr = parse_map_entry(buf_ptr, &start, &end, prot_buf, &maj_dev); +- if (buf_ptr == NULL) return; + ++ for (;;) { ++ buf_ptr = GC_parse_map_entry(buf_ptr, &start, &end, prot_buf, &maj_dev); ++ if (buf_ptr == NULL) return 1; + if (prot_buf[1] == 'w') { + /* This is a writable mapping. Add it to */ + /* the root set unless it is already otherwise */ +@@ -358,16 +325,7 @@ + # ifdef THREADS + if (GC_segment_is_thread_stack(start, end)) continue; + # endif +- /* The rest of this assumes that there is no mapping */ +- /* spanning the beginning of the data segment, or extending */ +- /* beyond the entire heap at both ends. */ +- /* Empirically these assumptions hold. */ +- +- if (start < (word)DATAEND && end > (word)DATAEND) { +- /* Rld may use space at the end of the main data */ +- /* segment. Thus we add that in. */ +- start = (word)DATAEND; +- } ++ /* We no longer exclude the main data segment. */ + if (start < least_ha && end > least_ha) { + end = least_ha; + } +@@ -378,6 +336,13 @@ + GC_add_roots_inner((char *)start, (char *)end, TRUE); + } + } ++ return 1; ++} ++ ++void GC_register_dynamic_libraries() ++{ ++ if (!GC_apply_to_maps(GC_register_map_entries)) ++ ABORT("Failed to read /proc for library registration."); + } + + /* We now take care of the main data segment ourselves: */ +@@ -387,60 +352,6 @@ + } + + # define HAVE_REGISTER_MAIN_STATIC_DATA +-// +-// parse_map_entry parses an entry from /proc/self/maps so we can +-// locate all writable data segments that belong to shared libraries. +-// The format of one of these entries and the fields we care about +-// is as follows: +-// XXXXXXXX-XXXXXXXX r-xp 00000000 30:05 260537 name of mapping...\n +-// ^^^^^^^^ ^^^^^^^^ ^^^^ ^^ +-// start end prot maj_dev +-// 0 9 18 32 +-// +-// The parser is called with a pointer to the entry and the return value +-// is either NULL or is advanced to the next entry(the byte after the +-// trailing '\n'.) +-// +-#define OFFSET_MAP_START 0 +-#define OFFSET_MAP_END 9 +-#define OFFSET_MAP_PROT 18 +-#define OFFSET_MAP_MAJDEV 32 +- +-static char *parse_map_entry(char *buf_ptr, word *start, word *end, +- char *prot_buf, unsigned int *maj_dev) +-{ +- int i; +- unsigned int val; +- char *tok; +- +- if (buf_ptr == NULL || *buf_ptr == '\0') { +- return NULL; +- } +- +- memcpy(prot_buf, buf_ptr+OFFSET_MAP_PROT, 4); // do the protections first +- prot_buf[4] = '\0'; +- +- if (prot_buf[1] == 'w') { // we can skip all of this if it's not writable +- +- tok = buf_ptr; +- buf_ptr[OFFSET_MAP_START+8] = '\0'; +- *start = strtoul(tok, NULL, 16); +- +- tok = buf_ptr+OFFSET_MAP_END; +- buf_ptr[OFFSET_MAP_END+8] = '\0'; +- *end = strtoul(tok, NULL, 16); +- +- buf_ptr += OFFSET_MAP_MAJDEV; +- tok = buf_ptr; +- while (*buf_ptr != ':') buf_ptr++; +- *buf_ptr++ = '\0'; +- *maj_dev = strtoul(tok, NULL, 16); +- } +- +- while (*buf_ptr && *buf_ptr++ != '\n'); +- +- return buf_ptr; +-} + + #endif /* USE_PROC_FOR_LIBRARIES */ + +@@ -508,6 +419,7 @@ + GC_add_roots_inner(DATASTART2, (char *)(DATAEND2), TRUE); + # endif + } ++ + return TRUE; + } else { + return FALSE; +@@ -630,6 +542,7 @@ + /* The type is a lie, since the real type doesn't make sense here, */ + /* and we only test for NULL. */ + ++ + /* We use /proc to track down all parts of the address space that are */ + /* mapped by the process, and throw out regions we know we shouldn't */ + /* worry about. This may also work under other SVR4 variants. */ +@@ -1056,7 +969,122 @@ + } + #endif /* RS6000 */ + ++#ifdef DARWIN ++ ++#include ++#include ++ ++/*#define DARWIN_DEBUG*/ ++ ++const static struct { ++ const char *seg; ++ const char *sect; ++} GC_dyld_sections[] = { ++ { SEG_DATA, SECT_DATA }, ++ { SEG_DATA, SECT_BSS }, ++ { SEG_DATA, SECT_COMMON } ++}; ++ ++#ifdef DARWIN_DEBUG ++static const char *GC_dyld_name_for_hdr(struct mach_header *hdr) { ++ unsigned long i,c; ++ c = _dyld_image_count(); ++ for(i=0;isize == 0) continue; ++ start = slide + sec->addr; ++ end = start + sec->size; ++# ifdef DARWIN_DEBUG ++ GC_printf4("Adding section at %p-%p (%lu bytes) from image %s\n", ++ start,end,sec->size,GC_dyld_name_for_hdr(hdr)); ++# endif ++ GC_add_roots((char*)start,(char*)end); ++ } ++# ifdef DARWIN_DEBUG ++ GC_print_static_roots(); ++# endif ++} ++ ++/* This should never be called by a thread holding the lock */ ++static void GC_dyld_image_remove(struct mach_header* hdr, unsigned long slide) { ++ unsigned long start,end,i; ++ const struct section *sec; ++ for(i=0;isize == 0) continue; ++ start = slide + sec->addr; ++ end = start + sec->size; ++# ifdef DARWIN_DEBUG ++ GC_printf4("Removing section at %p-%p (%lu bytes) from image %s\n", ++ start,end,sec->size,GC_dyld_name_for_hdr(hdr)); ++# endif ++ GC_remove_roots((char*)start,(char*)end); ++ } ++# ifdef DARWIN_DEBUG ++ GC_print_static_roots(); ++# endif ++} ++ ++void GC_register_dynamic_libraries() { ++ /* Currently does nothing. The callbacks are setup by GC_init_dyld() ++ The dyld library takes it from there. */ ++} ++ ++/* The _dyld_* functions have an internal lock so no _dyld functions ++ can be called while the world is stopped without the risk of a deadlock. ++ Because of this we MUST setup callbacks BEFORE we ever stop the world. ++ This should be called BEFORE any thread in created and WITHOUT the ++ allocation lock held. */ ++ ++void GC_init_dyld() { ++ static GC_bool initialized = FALSE; ++ ++ if(initialized) return; ++ ++# ifdef DARWIN_DEBUG ++ GC_printf0("Forcing full bind of GC code...\n"); ++# endif ++ if(!_dyld_bind_fully_image_containing_address((unsigned long*)GC_malloc)) ++ GC_abort("_dyld_bind_fully_image_containing_addres failed"); ++ ++# ifdef DARWIN_DEBUG ++ GC_printf0("Registering dyld callbacks...\n"); ++# endif ++ ++ /* Apple's Documentation: ++ When you call _dyld_register_func_for_add_image, the dynamic linker runtime ++ calls the specified callback (func) once for each of the images that is ++ currently loaded into the program. When a new image is added to the program, ++ your callback is called again with the mach_header for the new image, and the virtual memory slide amount of the new image. ++ ++ This WILL properly register existing and all future libraries ++ */ ++ ++ _dyld_register_func_for_add_image(GC_dyld_image_add); ++ _dyld_register_func_for_remove_image(GC_dyld_image_remove); ++ initialized = TRUE; ++} ++ ++#define HAVE_REGISTER_MAIN_STATIC_DATA ++GC_bool GC_register_main_static_data() ++{ ++ /* Already done through dyld callbacks */ ++ return FALSE; ++} + ++#endif /* DARWIN */ + + #else /* !DYNAMIC_LOADING */ + +diff -urNb boehm-gc/finalize.c boehm-gc/finalize.c +--- boehm-gc/finalize.c Mon Feb 11 20:37:53 2002 ++++ boehm-gc/finalize.c Mon May 26 12:48:52 2003 +@@ -207,7 +207,8 @@ + UNLOCK(); + ENABLE_SIGNALS(); + # endif +- new_dl = GC_oom_fn(sizeof(struct disappearing_link)); ++ new_dl = (struct disappearing_link *) ++ GC_oom_fn(sizeof(struct disappearing_link)); + if (0 == new_dl) { + GC_finalization_failures++; + return(0); +@@ -433,7 +434,8 @@ + UNLOCK(); + ENABLE_SIGNALS(); + # endif +- new_fo = GC_oom_fn(sizeof(struct finalizable_object)); ++ new_fo = (struct finalizable_object *) ++ GC_oom_fn(sizeof(struct finalizable_object)); + if (0 == new_fo) { + GC_finalization_failures++; + return; +@@ -759,8 +761,9 @@ + /* Should be called without allocation lock. */ + int GC_invoke_finalizers() + { +- register struct finalizable_object * curr_fo; +- register int count = 0; ++ struct finalizable_object * curr_fo; ++ int count = 0; ++ word mem_freed_before; + DCL_LOCK_STATE; + + while (GC_finalize_now != 0) { +@@ -768,6 +771,9 @@ + DISABLE_SIGNALS(); + LOCK(); + # endif ++ if (count == 0) { ++ mem_freed_before = GC_mem_freed; ++ } + curr_fo = GC_finalize_now; + # ifdef THREADS + if (curr_fo != 0) GC_finalize_now = fo_next(curr_fo); +@@ -789,6 +795,11 @@ + GC_free((GC_PTR)curr_fo); + # endif + } ++ if (count != 0 && mem_freed_before != GC_mem_freed) { ++ LOCK(); ++ GC_finalizer_mem_freed += (GC_mem_freed - mem_freed_before); ++ UNLOCK(); ++ } + return count; + } + +@@ -801,7 +812,9 @@ + if (GC_finalize_now == 0) return; + if (!GC_finalize_on_demand) { + (void) GC_invoke_finalizers(); ++# ifndef THREADS + GC_ASSERT(GC_finalize_now == 0); ++# endif /* Otherwise GC can run concurrently and add more */ + return; + } + if (GC_finalizer_notifier != (void (*) GC_PROTO((void)))0 +@@ -839,3 +852,17 @@ + return(result); + } + ++#if !defined(NO_DEBUGGING) ++ ++void GC_print_finalization_stats() ++{ ++ struct finalizable_object *fo = GC_finalize_now; ++ size_t ready = 0; ++ ++ GC_printf2("%lu finalization table entries; %lu disappearing links\n", ++ GC_fo_entries, GC_dl_entries); ++ for (; 0 != fo; fo = fo_next(fo)) ++ready; ++ GC_printf1("%lu objects are eligible for immediate finalization\n", ready); ++} ++ ++#endif /* NO_DEBUGGING */ +diff -urNb boehm-gc/gc_dlopen.c boehm-gc/gc_dlopen.c +--- boehm-gc/gc_dlopen.c Tue Oct 16 02:01:35 2001 ++++ boehm-gc/gc_dlopen.c Mon May 26 12:48:52 2003 +@@ -19,12 +19,14 @@ + /* + * This used to be in dyn_load.c. It was extracted into a separate file + * to avoid having to link against libdl.{a,so} if the client doesn't call +- * dlopen. -HB ++ * dlopen. Of course this fails if the collector is in a dynamic ++ * library. -HB + */ + + #include "private/gc_priv.h" + +-# if defined(GC_PTHREADS) || defined(GC_SOLARIS_THREADS) ++# if (defined(GC_PTHREADS) && !defined(GC_DARWIN_THREADS)) \ ++ || defined(GC_SOLARIS_THREADS) + + # if defined(dlopen) && !defined(GC_USE_LD_WRAP) + /* To support various threads pkgs, gc.h interposes on dlopen by */ +@@ -44,19 +46,14 @@ + /* calls in either a multithreaded environment, or if the library */ + /* initialization code allocates substantial amounts of GC'ed memory. */ + /* But I don't know of a better solution. */ +- /* This can still deadlock if the client explicitly starts a GC */ +- /* during the dlopen. He shouldn't do that. */ +- static GC_bool disable_gc_for_dlopen() ++ static void disable_gc_for_dlopen() + { +- GC_bool result; + LOCK(); +- result = GC_dont_gc; + while (GC_incremental && GC_collection_in_progress()) { + GC_collect_a_little_inner(1000); + } +- GC_dont_gc = TRUE; ++ ++GC_dont_gc; + UNLOCK(); +- return(result); + } + + /* Redefine dlopen to guarantee mutual exclusion with */ +@@ -74,10 +71,9 @@ + #endif + { + void * result; +- GC_bool dont_gc_save; + + # ifndef USE_PROC_FOR_LIBRARIES +- dont_gc_save = disable_gc_for_dlopen(); ++ disable_gc_for_dlopen(); + # endif + # ifdef GC_USE_LD_WRAP + result = (void *)__real_dlopen(path, mode); +@@ -85,7 +81,7 @@ + result = dlopen(path, mode); + # endif + # ifndef USE_PROC_FOR_LIBRARIES +- GC_dont_gc = dont_gc_save; ++ GC_enable(); /* undoes disable_gc_for_dlopen */ + # endif + return(result); + } +diff -urNb boehm-gc/gcj_mlc.c boehm-gc/gcj_mlc.c +--- boehm-gc/gcj_mlc.c Mon Feb 11 20:37:53 2002 ++++ boehm-gc/gcj_mlc.c Mon May 26 12:48:52 2003 +@@ -157,6 +157,7 @@ + GC_words_allocd += lw; + } + *(void **)op = ptr_to_struct_containing_descr; ++ GC_ASSERT(((void **)op)[1] == 0); + UNLOCK(); + } else { + LOCK(); +diff -urNb boehm-gc/if_mach.c boehm-gc/if_mach.c +--- boehm-gc/if_mach.c Fri Aug 17 11:30:45 2001 ++++ boehm-gc/if_mach.c Mon May 26 12:48:52 2003 +@@ -14,7 +14,7 @@ + if (strcmp(MACH_TYPE, argv[1]) != 0) return(0); + if (strcmp(OS_TYPE, "") != 0 && strcmp(argv[2], "") != 0 + && strcmp(OS_TYPE, argv[2]) != 0) return(0); +- printf("^^^^Starting command^^^^\n"); ++ fprintf(stderr, "^^^^Starting command^^^^\n"); + fflush(stdout); + execvp(argv[3], argv+3); + perror("Couldn't execute"); +diff -urNb boehm-gc/include/Makefile.in boehm-gc/include/Makefile.in +--- boehm-gc/include/Makefile.in Tue Dec 31 09:52:45 2002 ++++ boehm-gc/include/Makefile.in Mon May 26 13:08:48 2003 +@@ -1,6 +1,8 @@ +-# Makefile.in generated automatically by automake 1.4 from Makefile.am ++# Makefile.in generated by automake 1.6.3 from Makefile.am. ++# @configure_input@ + +-# Copyright (C) 1994, 1995-8, 1999 Free Software Foundation, Inc. ++# Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 ++# Free Software Foundation, Inc. + # This Makefile.in is free software; the Free Software Foundation + # gives unlimited permission to copy and/or distribute it, + # with or without modifications, as long as this notice is preserved. +@@ -10,7 +12,7 @@ + # even the implied warranty of MERCHANTABILITY or FITNESS FOR A + # PARTICULAR PURPOSE. + +- ++@SET_MAKE@ + SHELL = @SHELL@ + + srcdir = @srcdir@ +@@ -31,13 +33,9 @@ + mandir = @mandir@ + includedir = @includedir@ + oldincludedir = /usr/include +- +-DESTDIR = +- + pkgdatadir = $(datadir)/@PACKAGE@ + pkglibdir = $(libdir)/@PACKAGE@ + pkgincludedir = $(includedir)/@PACKAGE@ +- + top_builddir = .. + + ACLOCAL = @ACLOCAL@ +@@ -45,12 +43,16 @@ + AUTOMAKE = @AUTOMAKE@ + AUTOHEADER = @AUTOHEADER@ + ++am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd + INSTALL = @INSTALL@ +-INSTALL_PROGRAM = @INSTALL_PROGRAM@ $(AM_INSTALL_PROGRAM_FLAGS) ++INSTALL_PROGRAM = @INSTALL_PROGRAM@ + INSTALL_DATA = @INSTALL_DATA@ ++install_sh_DATA = $(install_sh) -c -m 644 ++install_sh_PROGRAM = $(install_sh) -c ++install_sh_SCRIPT = $(install_sh) -c + INSTALL_SCRIPT = @INSTALL_SCRIPT@ ++INSTALL_HEADER = $(INSTALL_DATA) + transform = @program_transform_name@ +- + NORMAL_INSTALL = : + PRE_INSTALL = : + POST_INSTALL = : +@@ -63,171 +65,190 @@ + host_triplet = @host@ + target_alias = @target_alias@ + target_triplet = @target@ ++ ++EXEEXT = @EXEEXT@ ++OBJEXT = @OBJEXT@ ++PATH_SEPARATOR = @PATH_SEPARATOR@ ++AMTAR = @AMTAR@ + AR = @AR@ + AS = @AS@ ++AWK = @AWK@ + CC = @CC@ + CPP = @CPP@ + CXX = @CXX@ + CXXCPP = @CXXCPP@ + CXXINCLUDES = @CXXINCLUDES@ ++DEPDIR = @DEPDIR@ + DLLTOOL = @DLLTOOL@ +-EXEEXT = @EXEEXT@ ++ECHO = @ECHO@ ++EGREP = @EGREP@ + EXTRA_TEST_LIBS = @EXTRA_TEST_LIBS@ ++F77 = @F77@ + GCJ = @GCJ@ + GCJFLAGS = @GCJFLAGS@ + GC_CFLAGS = @GC_CFLAGS@ + INCLUDES = @INCLUDES@ ++INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ + LIBTOOL = @LIBTOOL@ + LN_S = @LN_S@ + MAINT = @MAINT@ +-MAKEINFO = @MAKEINFO@ + MY_CFLAGS = @MY_CFLAGS@ + OBJDUMP = @OBJDUMP@ +-OBJEXT = @OBJEXT@ + PACKAGE = @PACKAGE@ + RANLIB = @RANLIB@ ++RC = @RC@ + STRIP = @STRIP@ + THREADLIBS = @THREADLIBS@ + VERSION = @VERSION@ + addobjs = @addobjs@ ++am__include = @am__include@ ++am__quote = @am__quote@ + gc_basedir = @gc_basedir@ ++install_sh = @install_sh@ + mkinstalldirs = @mkinstalldirs@ + target_all = @target_all@ +- + AUTOMAKE_OPTIONS = foreign + + noinst_HEADERS = gc.h gc_backptr.h gc_local_alloc.h \ + gc_pthread_redirects.h gc_cpp.h + ++subdir = include + CONFIG_CLEAN_FILES = ++depcomp = ++am__depfiles_maybe = ++DIST_SOURCES = + HEADERS = $(noinst_HEADERS) + +-DIST_COMMON = Makefile.am Makefile.in +- ++all: all-am + +-DISTFILES = $(DIST_COMMON) $(SOURCES) $(HEADERS) $(TEXINFOS) $(EXTRA_DIST) +- +-TAR = gtar +-GZIP_ENV = --best +-all: all-redirect + .SUFFIXES: + $(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ Makefile.am $(top_srcdir)/configure.in $(ACLOCAL_M4) +- cd $(top_srcdir) && $(AUTOMAKE) --cygnus include/Makefile ++ cd $(top_srcdir) && \ ++ $(AUTOMAKE) --cygnus include/Makefile ++Makefile: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.in $(top_builddir)/config.status ++ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe) + +-Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status +- cd $(top_builddir) \ +- && CONFIG_FILES=$(subdir)/$@ CONFIG_HEADERS= $(SHELL) ./config.status ++mostlyclean-libtool: ++ -rm -f *.lo + ++clean-libtool: ++ -rm -rf .libs _libs ++ ++distclean-libtool: ++ -rm -f libtool ++uninstall-info-am: ++ ++ETAGS = etags ++ETAGSFLAGS = + + tags: TAGS + +-ID: $(HEADERS) $(SOURCES) $(LISP) +- list='$(SOURCES) $(HEADERS)'; \ +- unique=`for i in $$list; do echo $$i; done | \ +- awk ' { files[$$0] = 1; } \ ++ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES) ++ list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ ++ unique=`for i in $$list; do \ ++ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ ++ done | \ ++ $(AWK) ' { files[$$0] = 1; } \ + END { for (i in files) print i; }'`; \ +- here=`pwd` && cd $(srcdir) \ +- && mkid -f$$here/ID $$unique $(LISP) ++ mkid -fID $$unique + +-TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) $(LISP) ++TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ ++ $(TAGS_FILES) $(LISP) + tags=; \ + here=`pwd`; \ +- list='$(SOURCES) $(HEADERS)'; \ +- unique=`for i in $$list; do echo $$i; done | \ +- awk ' { files[$$0] = 1; } \ ++ list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ ++ unique=`for i in $$list; do \ ++ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ ++ done | \ ++ $(AWK) ' { files[$$0] = 1; } \ + END { for (i in files) print i; }'`; \ +- test -z "$(ETAGS_ARGS)$$unique$(LISP)$$tags" \ +- || (cd $(srcdir) && etags $(ETAGS_ARGS) $$tags $$unique $(LISP) -o $$here/TAGS) +- +-mostlyclean-tags: +- +-clean-tags: ++ test -z "$(ETAGS_ARGS)$$tags$$unique" \ ++ || $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ ++ $$tags $$unique ++ ++GTAGS: ++ here=`$(am__cd) $(top_builddir) && pwd` \ ++ && cd $(top_srcdir) \ ++ && gtags -i $(GTAGS_ARGS) $$here + + distclean-tags: +- -rm -f TAGS ID +- +-maintainer-clean-tags: +- +-distdir = $(top_builddir)/$(PACKAGE)-$(VERSION)/$(subdir) +- +-subdir = include +- +-distdir: $(DISTFILES) +- @for file in $(DISTFILES); do \ +- if test -f $$file; then d=.; else d=$(srcdir); fi; \ +- if test -d $$d/$$file; then \ +- cp -pr $$d/$$file $(distdir)/$$file; \ +- else \ +- test -f $(distdir)/$$file \ +- || ln $$d/$$file $(distdir)/$$file 2> /dev/null \ +- || cp -p $$d/$$file $(distdir)/$$file || :; \ +- fi; \ +- done +-info-am: +-info: info-am +-dvi-am: +-dvi: dvi-am ++ -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH + check-am: + check: check-am +-installcheck-am: +-installcheck: installcheck-am +-install-info-am: +-install-info: install-info-am +-install-exec-am: +-install-exec: install-exec-am ++all-am: Makefile $(HEADERS) + +-install-data-am: +-install-data: install-data-am ++installdirs: + +-install-am: all-am +- @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + install: install-am +-uninstall-am: ++install-exec: install-exec-am ++install-data: install-data-am + uninstall: uninstall-am +-all-am: Makefile $(HEADERS) +-all-redirect: all-am +-install-strip: +- $(MAKE) $(AM_MAKEFLAGS) AM_INSTALL_PROGRAM_FLAGS=-s install +-installdirs: + ++install-am: all-am ++ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + ++installcheck: installcheck-am ++install-strip: ++ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ ++ INSTALL_STRIP_FLAG=-s \ ++ `test -z '$(STRIP)' || \ ++ echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install + mostlyclean-generic: + + clean-generic: + + distclean-generic: + -rm -f Makefile $(CONFIG_CLEAN_FILES) +- -rm -f config.cache config.log stamp-h stamp-h[0-9]* + + maintainer-clean-generic: +-mostlyclean-am: mostlyclean-tags mostlyclean-generic ++ @echo "This command is intended for maintainers to use" ++ @echo "it deletes files that may require special tools to rebuild." ++clean: clean-am + +-mostlyclean: mostlyclean-am ++clean-am: clean-generic clean-libtool mostlyclean-am + +-clean-am: clean-tags clean-generic mostlyclean-am ++distclean: distclean-am + +-clean: clean-am ++distclean-am: clean-am distclean-generic distclean-libtool \ ++ distclean-tags + +-distclean-am: distclean-tags distclean-generic clean-am +- -rm -f libtool ++dvi: dvi-am + +-distclean: distclean-am ++dvi-am: + +-maintainer-clean-am: maintainer-clean-tags maintainer-clean-generic \ +- distclean-am +- @echo "This command is intended for maintainers to use;" +- @echo "it deletes files that may require special tools to rebuild." ++info: info-am ++ ++info-am: ++ ++install-data-am: ++ ++install-exec-am: ++ ++install-info: ++ ++install-man: ++ ++installcheck-am: + + maintainer-clean: maintainer-clean-am + +-.PHONY: tags mostlyclean-tags distclean-tags clean-tags \ +-maintainer-clean-tags distdir info-am info dvi-am dvi check check-am \ +-installcheck-am installcheck install-info-am install-info \ +-install-exec-am install-exec install-data-am install-data install-am \ +-install uninstall-am uninstall all-redirect all-am all installdirs \ +-mostlyclean-generic distclean-generic clean-generic \ +-maintainer-clean-generic clean mostlyclean distclean maintainer-clean ++maintainer-clean-am: distclean-am maintainer-clean-generic ++ ++mostlyclean: mostlyclean-am ++ ++mostlyclean-am: mostlyclean-generic mostlyclean-libtool ++ ++uninstall-am: + ++.PHONY: GTAGS all all-am check check-am clean clean-generic \ ++ clean-libtool distclean distclean-generic distclean-libtool \ ++ distclean-tags dvi dvi-am info info-am install install-am \ ++ install-data install-data-am install-exec install-exec-am \ ++ install-info install-info-am install-man install-strip \ ++ installcheck installcheck-am installdirs maintainer-clean \ ++ maintainer-clean-generic mostlyclean mostlyclean-generic \ ++ mostlyclean-libtool tags uninstall uninstall-am \ ++ uninstall-info-am + + # Tell versions [3.59,3.63) of GNU make to not export all variables. + # Otherwise a system limit (for SysV at least) may be exceeded. +diff -urNb boehm-gc/include/gc.h boehm-gc/include/gc.h +--- boehm-gc/include/gc.h Mon Feb 11 20:37:56 2002 ++++ boehm-gc/include/gc.h Mon May 26 13:28:19 2003 +@@ -30,91 +30,7 @@ + + # define _GC_H + +-/* +- * Some tests for old macros. These violate our namespace rules and will +- * disappear shortly. Use the GC_ names. +- */ +-#if defined(SOLARIS_THREADS) || defined(_SOLARIS_THREADS) +-# define GC_SOLARIS_THREADS +-#endif +-#if defined(_SOLARIS_PTHREADS) +-# define GC_SOLARIS_PTHREADS +-#endif +-#if defined(IRIX_THREADS) +-# define GC_IRIX_THREADS +-#endif +-#if defined(HPUX_THREADS) +-# define GC_HPUX_THREADS +-#endif +-#if defined(OSF1_THREADS) +-# define GC_OSF1_THREADS +-#endif +-#if defined(LINUX_THREADS) +-# define GC_LINUX_THREADS +-#endif +-#if defined(WIN32_THREADS) +-# define GC_WIN32_THREADS +-#endif +-#if defined(USE_LD_WRAP) +-# define GC_USE_LD_WRAP +-#endif +- +-#if !defined(_REENTRANT) && (defined(GC_SOLARIS_THREADS) \ +- || defined(GC_SOLARIS_PTHREADS) \ +- || defined(GC_HPUX_THREADS) \ +- || defined(GC_LINUX_THREADS)) +-# define _REENTRANT +- /* Better late than never. This fails if system headers that */ +- /* depend on this were previously included. */ +-#endif +- +-#if defined(GC_SOLARIS_PTHREADS) && !defined(GC_SOLARIS_THREADS) +-# define GC_SOLARIS_THREADS +-#endif +- +-# if defined(GC_SOLARIS_PTHREADS) || defined(GC_FREEBSD_THREADS) || \ +- defined(GC_IRIX_THREADS) || defined(GC_LINUX_THREADS) || \ +- defined(GC_HPUX_THREADS) || defined(GC_OSF1_THREADS) +-# define GC_PTHREADS +-# endif +- +-# define __GC +-# include +-# ifdef _WIN32_WCE +-/* Yet more kluges for WinCE */ +-# include /* size_t is defined here */ +- typedef long ptrdiff_t; /* ptrdiff_t is not defined */ +-# endif +- +-#if defined(__MINGW32__) &&defined(_DLL) && !defined(GC_NOT_DLL) +-# ifdef GC_BUILD +-# define GC_API __declspec(dllexport) +-# else +-# define GC_API __declspec(dllimport) +-# endif +-#endif +- +-#if (defined(__DMC__) || defined(_MSC_VER)) \ +- && (defined(_DLL) && !defined(GC_NOT_DLL) \ +- || defined(GC_DLL)) +-# ifdef GC_BUILD +-# define GC_API extern __declspec(dllexport) +-# else +-# define GC_API __declspec(dllimport) +-# endif +-#endif +- +-#if defined(__WATCOMC__) && defined(GC_DLL) +-# ifdef GC_BUILD +-# define GC_API extern __declspec(dllexport) +-# else +-# define GC_API extern __declspec(dllimport) +-# endif +-#endif +- +-#ifndef GC_API +-#define GC_API extern +-#endif ++# include "gc_config_macros.h" + + # if defined(__STDC__) || defined(__cplusplus) + # define GC_PROTO(args) args +@@ -154,7 +70,7 @@ + /* Env variable GC_NPROC is set to > 1, or */ + /* GC_NPROC is not set and this is an MP. */ + /* If GC_parallel is set, incremental */ +- /* collection is aonly partially functional, */ ++ /* collection is only partially functional, */ + /* and may not be desirable. */ + + +@@ -215,8 +131,14 @@ + /* thread, which will call GC_invoke_finalizers */ + /* in response. */ + +-GC_API int GC_dont_gc; /* Dont collect unless explicitly requested, e.g. */ +- /* because it's not safe. */ ++GC_API int GC_dont_gc; /* != 0 ==> Dont collect. In versions 7.2a1+, */ ++ /* this overrides explicit GC_gcollect() calls. */ ++ /* Used as a counter, so that nested enabling */ ++ /* and disabling work correctly. Should */ ++ /* normally be updated with GC_enable() and */ ++ /* GC_disable() calls. */ ++ /* Direct assignment to GC_dont_gc is */ ++ /* deprecated. */ + + GC_API int GC_dont_expand; + /* Dont expand heap unless explicitly requested */ +@@ -296,15 +218,6 @@ + /* Interferes with blacklisting. */ + /* Wizards only. */ + +-/* Public procedures */ +- +-/* Initialize the collector. This is only required when using thread-local +- * allocation, since unlike the regular allocation routines, GC_local_malloc +- * is not self-initializing. If you use GC_local_malloc you should arrange +- * to call this somehow (e.g. from a constructor) before doing any allocation. +- */ +-GC_API void GC_init GC_PROTO((void)); +- + GC_API unsigned long GC_time_limit; + /* If incremental collection is enabled, */ + /* We try to terminate collections */ +@@ -316,9 +229,18 @@ + /* enabled. */ + # define GC_TIME_UNLIMITED 999999 + /* Setting GC_time_limit to this value */ +- /* will disable the "pause time exceeded */ ++ /* will disable the "pause time exceeded"*/ + /* tests. */ + ++/* Public procedures */ ++ ++/* Initialize the collector. This is only required when using thread-local ++ * allocation, since unlike the regular allocation routines, GC_local_malloc ++ * is not self-initializing. If you use GC_local_malloc you should arrange ++ * to call this somehow (e.g. from a constructor) before doing any allocation. ++ */ ++GC_API void GC_init GC_PROTO((void)); ++ + /* + * general purpose allocation routines, with roughly malloc calling conv. + * The atomic versions promise that no relevant pointers are contained +@@ -419,17 +341,21 @@ + GC_API void GC_add_roots GC_PROTO((char * low_address, + char * high_address_plus_1)); + ++/* Remove a root segment. Wizards only. */ ++GC_API void GC_remove_roots GC_PROTO((char * low_address, ++ char * high_address_plus_1)); ++ + /* Add a displacement to the set of those considered valid by the */ + /* collector. GC_register_displacement(n) means that if p was returned */ + /* by GC_malloc, then (char *)p + n will be considered to be a valid */ +-/* pointer to n. N must be small and less than the size of p. */ ++/* pointer to p. N must be small and less than the size of p. */ + /* (All pointers to the interior of objects from the stack are */ + /* considered valid in any case. This applies to heap objects and */ + /* static data.) */ + /* Preferably, this should be called before any other GC procedures. */ + /* Calling it later adds to the probability of excess memory */ + /* retention. */ +-/* This is a no-op if the collector was compiled with recognition of */ ++/* This is a no-op if the collector has recognition of */ + /* arbitrary interior pointers enabled, which is now the default. */ + GC_API void GC_register_displacement GC_PROTO((GC_word n)); + +@@ -464,9 +390,18 @@ + GC_API size_t GC_get_bytes_since_gc GC_PROTO((void)); + + /* Return the total number of bytes allocated in this process. */ +-/* Never decreases. */ ++/* Never decreases, except due to wrapping. */ + GC_API size_t GC_get_total_bytes GC_PROTO((void)); + ++/* Disable garbage collection. Even GC_gcollect calls will be */ ++/* ineffective. */ ++GC_API void GC_disable GC_PROTO((void)); ++ ++/* Reenable garbage collection. GC_diable() and GC_enable() calls */ ++/* nest. Garbage collection is enabled if the number of calls to both */ ++/* both functions is equal. */ ++GC_API void GC_enable GC_PROTO((void)); ++ + /* Enable incremental/generational collection. */ + /* Not advisable unless dirty bits are */ + /* available or most heap objects are */ +@@ -474,7 +409,11 @@ + /* Don't use in leak finding mode. */ + /* Ignored if GC_dont_gc is true. */ + /* Only the generational piece of this is */ +-/* functional if GC_parallel is TRUE. */ ++/* functional if GC_parallel is TRUE */ ++/* or if GC_time_limit is GC_TIME_UNLIMITED. */ ++/* Causes GC_local_gcj_malloc() to revert to */ ++/* locked allocation. Must be called */ ++/* before any GC_local_gcj_malloc() calls. */ + GC_API void GC_enable_incremental GC_PROTO((void)); + + /* Does incremental mode write-protect pages? Returns zero or */ +@@ -518,6 +457,42 @@ + # define GC_RETURN_ADDR (GC_word)__return_address + #endif + ++#ifdef __linux__ ++# include ++# if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1 || __GLIBC__ > 2) \ ++ && !defined(__ia64__) ++# define GC_HAVE_BUILTIN_BACKTRACE ++# define GC_CAN_SAVE_CALL_STACKS ++# endif ++# if defined(__i386__) || defined(__x86_64__) ++# define GC_CAN_SAVE_CALL_STACKS ++# endif ++#endif ++ ++#if defined(__sparc__) ++# define GC_CAN_SAVE_CALL_STACKS ++#endif ++ ++/* If we're on an a platform on which we can't save call stacks, but */ ++/* gcc is normally used, we go ahead and define GC_ADD_CALLER. */ ++/* We make this decision independent of whether gcc is actually being */ ++/* used, in order to keep the interface consistent, and allow mixing */ ++/* of compilers. */ ++/* This may also be desirable if it is possible but expensive to */ ++/* retrieve the call chain. */ ++#if (defined(__linux__) || defined(__NetBSD__) || defined(__OpenBSD__) \ ++ || defined(__FreeBSD__)) & !defined(GC_CAN_SAVE_CALL_STACKS) ++# define GC_ADD_CALLER ++# if __GNUC__ >= 3 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95) ++ /* gcc knows how to retrieve return address, but we don't know */ ++ /* how to generate call stacks. */ ++# define GC_RETURN_ADDR (GC_word)__builtin_return_address(0) ++# else ++ /* Just pass 0 for gcc compatibility. */ ++# define GC_RETURN_ADDR 0 ++# endif ++#endif ++ + #ifdef GC_ADD_CALLER + # define GC_EXTRAS GC_RETURN_ADDR, __FILE__, __LINE__ + # define GC_EXTRA_PARAMS GC_word ra, GC_CONST char * s, int i +@@ -536,18 +511,42 @@ + GC_PROTO((size_t size_in_bytes, GC_EXTRA_PARAMS)); + GC_API GC_PTR GC_debug_malloc_stubborn + GC_PROTO((size_t size_in_bytes, GC_EXTRA_PARAMS)); ++GC_API GC_PTR GC_debug_malloc_ignore_off_page ++ GC_PROTO((size_t size_in_bytes, GC_EXTRA_PARAMS)); ++GC_API GC_PTR GC_debug_malloc_atomic_ignore_off_page ++ GC_PROTO((size_t size_in_bytes, GC_EXTRA_PARAMS)); + GC_API void GC_debug_free GC_PROTO((GC_PTR object_addr)); + GC_API GC_PTR GC_debug_realloc + GC_PROTO((GC_PTR old_object, size_t new_size_in_bytes, + GC_EXTRA_PARAMS)); +- + GC_API void GC_debug_change_stubborn GC_PROTO((GC_PTR)); + GC_API void GC_debug_end_stubborn_change GC_PROTO((GC_PTR)); ++ ++/* Routines that allocate objects with debug information (like the */ ++/* above), but just fill in dummy file and line number information. */ ++/* Thus they can serve as drop-in malloc/realloc replacements. This */ ++/* can be useful for two reasons: */ ++/* 1) It allows the collector to be built with DBG_HDRS_ALL defined */ ++/* even if some allocation calls come from 3rd party libraries */ ++/* that can't be recompiled. */ ++/* 2) On some platforms, the file and line information is redundant, */ ++/* since it can be reconstructed from a stack trace. On such */ ++/* platforms it may be more convenient not to recompile, e.g. for */ ++/* leak detection. This can be accomplished by instructing the */ ++/* linker to replace malloc/realloc with these. */ ++GC_API GC_PTR GC_debug_malloc_replacement GC_PROTO((size_t size_in_bytes)); ++GC_API GC_PTR GC_debug_realloc_replacement ++ GC_PROTO((GC_PTR object_addr, size_t size_in_bytes)); ++ + # ifdef GC_DEBUG + # define GC_MALLOC(sz) GC_debug_malloc(sz, GC_EXTRAS) + # define GC_MALLOC_ATOMIC(sz) GC_debug_malloc_atomic(sz, GC_EXTRAS) +-# define GC_MALLOC_UNCOLLECTABLE(sz) GC_debug_malloc_uncollectable(sz, \ +- GC_EXTRAS) ++# define GC_MALLOC_UNCOLLECTABLE(sz) \ ++ GC_debug_malloc_uncollectable(sz, GC_EXTRAS) ++# define GC_MALLOC_IGNORE_OFF_PAGE(sz) \ ++ GC_debug_malloc_ignore_off_page(sz, GC_EXTRAS) ++# define GC_MALLOC_ATOMIC_IGNORE_OFF_PAGE(sz) \ ++ GC_debug_malloc_atomic_ignore_off_page(sz, GC_EXTRAS) + # define GC_REALLOC(old, sz) GC_debug_realloc(old, sz, GC_EXTRAS) + # define GC_FREE(p) GC_debug_free(p) + # define GC_REGISTER_FINALIZER(p, f, d, of, od) \ +@@ -566,6 +565,10 @@ + # define GC_MALLOC(sz) GC_malloc(sz) + # define GC_MALLOC_ATOMIC(sz) GC_malloc_atomic(sz) + # define GC_MALLOC_UNCOLLECTABLE(sz) GC_malloc_uncollectable(sz) ++# define GC_MALLOC_IGNORE_OFF_PAGE(sz) \ ++ GC_malloc_ignore_off_page(sz) ++# define GC_MALLOC_ATOMIC_IGNORE_OFF_PAGE(sz) \ ++ GC_malloc_atomic_ignore_off_page(sz) + # define GC_REALLOC(old, sz) GC_realloc(old, sz) + # define GC_FREE(p) GC_free(p) + # define GC_REGISTER_FINALIZER(p, f, d, of, od) \ +@@ -644,7 +647,8 @@ + /* itself. There is a stylistic argument that this is wrong, */ + /* but it's unavoidable for C++, since the compiler may */ + /* silently introduce these. It's also benign in that specific */ +-/* case. */ ++/* case. And it helps if finalizable objects are split to */ ++/* avoid cycles. */ + /* Note that cd will still be viewed as accessible, even if it */ + /* refers to the object itself. */ + GC_API void GC_register_finalizer_ignore_self +@@ -717,11 +721,6 @@ + /* Undoes a registration by either of the above two */ + /* routines. */ + +-/* Auxiliary fns to make finalization work correctly with displaced */ +-/* pointers introduced by the debugging allocators. */ +-GC_API GC_PTR GC_make_closure GC_PROTO((GC_finalization_proc fn, GC_PTR data)); +-GC_API void GC_debug_invoke_finalizer GC_PROTO((GC_PTR obj, GC_PTR data)); +- + /* Returns !=0 if GC_invoke_finalizers has something to do. */ + GC_API int GC_should_invoke_finalizers GC_PROTO((void)); + +@@ -739,6 +738,10 @@ + GC_API GC_warn_proc GC_set_warn_proc GC_PROTO((GC_warn_proc p)); + /* Returns old warning procedure. */ + ++GC_API GC_word GC_set_free_space_divisor GC_PROTO((GC_word value)); ++ /* Set free_space_divisor. See above for definition. */ ++ /* Returns old value. */ ++ + /* The following is intended to be used by a higher level */ + /* (e.g. Java-like) finalization facility. It is expected */ + /* that finalization code will arrange for hidden pointers to */ +@@ -875,12 +878,16 @@ + + #if defined(GC_WIN32_THREADS) + # include ++# include + + /* + * All threads must be created using GC_CreateThread, so that they will be +- * recorded in the thread table. ++ * recorded in the thread table. For backwards compatibility, this is not ++ * technically true if the GC is built as a dynamic library, since it can ++ * and does then use DllMain to keep track of thread creations. But new code ++ * should be built to call GC_CreateThread. + */ +- HANDLE WINAPI GC_CreateThread( ++ GC_API HANDLE GC_CreateThread( + LPSECURITY_ATTRIBUTES lpThreadAttributes, + DWORD dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, + LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId ); +@@ -914,13 +921,18 @@ + # define GC_INIT() { extern end, etext; \ + GC_noop(&end, &etext); } + #else +-# if (defined(__CYGWIN32__) && defined(GC_USE_DLL)) || defined (_AIX) ++# if defined(__CYGWIN32__) && defined(GC_DLL) || defined (_AIX) + /* +- * Similarly gnu-win32 DLLs need explicit initialization ++ * Similarly gnu-win32 DLLs need explicit initialization from ++ * the main program, as does AIX. + */ + # define GC_INIT() { GC_add_roots(DATASTART, DATAEND); } + # else ++# if defined(__APPLE__) && defined(__MACH__) ++# define GC_INIT() { GC_init(); } ++# else + # define GC_INIT() ++# endif + # endif + #endif + +diff -urNb boehm-gc/include/gc_allocator.h boehm-gc/include/gc_allocator.h +--- boehm-gc/include/gc_allocator.h Wed Dec 31 16:00:00 1969 ++++ boehm-gc/include/gc_allocator.h Mon May 26 13:28:19 2003 +@@ -0,0 +1,232 @@ ++/* ++ * Copyright (c) 1996-1997 ++ * Silicon Graphics Computer Systems, Inc. ++ * ++ * Permission to use, copy, modify, distribute and sell this software ++ * and its documentation for any purpose is hereby granted without fee, ++ * provided that the above copyright notice appear in all copies and ++ * that both that copyright notice and this permission notice appear ++ * in supporting documentation. Silicon Graphics makes no ++ * representations about the suitability of this software for any ++ * purpose. It is provided "as is" without express or implied warranty. ++ * ++ * Copyright (c) 2002 ++ * Hewlett-Packard Company ++ * ++ * Permission to use, copy, modify, distribute and sell this software ++ * and its documentation for any purpose is hereby granted without fee, ++ * provided that the above copyright notice appear in all copies and ++ * that both that copyright notice and this permission notice appear ++ * in supporting documentation. Hewlett-Packard Company makes no ++ * representations about the suitability of this software for any ++ * purpose. It is provided "as is" without express or implied warranty. ++ */ ++ ++/* ++ * This implements standard-conforming allocators that interact with ++ * the garbage collector. Gc_alloctor allocates garbage-collectable ++ * objects of type T. Traceable_allocator allocates objects that ++ * are not temselves garbage collected, but are scanned by the ++ * collector for pointers to collectable objects. Traceable_alloc ++ * should be used for explicitly managed STL containers that may ++ * point to collectable objects. ++ * ++ * This code was derived from an earlier version of the GNU C++ standard ++ * library, which itself was derived from the SGI STL implementation. ++ */ ++ ++#include "gc.h" // For size_t ++ ++/* First some helpers to allow us to dispatch on whether or not a type ++ * is known to be pointerfree. ++ * These are private, except that the client may invoke the ++ * GC_DECLARE_PTRFREE macro. ++ */ ++ ++struct GC_true_type {}; ++struct GC_false_type {}; ++ ++template ++struct GC_type_traits { ++ GC_false_type GC_is_ptr_free; ++}; ++ ++# define GC_DECLARE_PTRFREE(T) \ ++template<> struct GC_type_traits { GC_true_type GC_is_ptr_free; } ++ ++GC_DECLARE_PTRFREE(signed char); ++GC_DECLARE_PTRFREE(unsigned char); ++GC_DECLARE_PTRFREE(signed short); ++GC_DECLARE_PTRFREE(unsigned short); ++GC_DECLARE_PTRFREE(signed int); ++GC_DECLARE_PTRFREE(unsigned int); ++GC_DECLARE_PTRFREE(signed long); ++GC_DECLARE_PTRFREE(unsigned long); ++GC_DECLARE_PTRFREE(float); ++GC_DECLARE_PTRFREE(double); ++/* The client may want to add others. */ ++ ++// In the following GC_Tp is GC_true_type iff we are allocating a ++// pointerfree object. ++template ++inline void * GC_selective_alloc(size_t n, GC_Tp) { ++ return GC_MALLOC(n); ++} ++ ++template <> ++inline void * GC_selective_alloc(size_t n, GC_true_type) { ++ return GC_MALLOC_ATOMIC(n); ++} ++ ++/* Now the public gc_allocator class: ++ */ ++template ++class gc_allocator { ++public: ++ typedef size_t size_type; ++ typedef ptrdiff_t difference_type; ++ typedef GC_Tp* pointer; ++ typedef const GC_Tp* const_pointer; ++ typedef GC_Tp& reference; ++ typedef const GC_Tp& const_reference; ++ typedef GC_Tp value_type; ++ ++ template struct rebind { ++ typedef gc_allocator other; ++ }; ++ ++ gc_allocator() {} ++# ifndef _MSC_VER ++ // I'm not sure why this is needed here in addition to the following. ++ // The standard specifies it for the standard allocator, but VC++ rejects ++ // it. -HB ++ gc_allocator(const gc_allocator&) throw() {} ++# endif ++ template gc_allocator(const gc_allocator&) throw() {} ++ ~gc_allocator() throw() {} ++ ++ pointer address(reference GC_x) const { return &GC_x; } ++ const_pointer address(const_reference GC_x) const { return &GC_x; } ++ ++ // GC_n is permitted to be 0. The C++ standard says nothing about what ++ // the return value is when GC_n == 0. ++ GC_Tp* allocate(size_type GC_n, const void* = 0) { ++ GC_type_traits traits; ++ return static_cast ++ (GC_selective_alloc(GC_n * sizeof(GC_Tp), ++ traits.GC_is_ptr_free)); ++ } ++ ++ // __p is not permitted to be a null pointer. ++ void deallocate(pointer __p, size_type GC_n) ++ { GC_FREE(__p); } ++ ++ size_type max_size() const throw() ++ { return size_t(-1) / sizeof(GC_Tp); } ++ ++ void construct(pointer __p, const GC_Tp& __val) { new(__p) GC_Tp(__val); } ++ void destroy(pointer __p) { __p->~GC_Tp(); } ++}; ++ ++template<> ++class gc_allocator { ++ typedef size_t size_type; ++ typedef ptrdiff_t difference_type; ++ typedef void* pointer; ++ typedef const void* const_pointer; ++ typedef void value_type; ++ ++ template struct rebind { ++ typedef gc_allocator other; ++ }; ++}; ++ ++ ++template ++inline bool operator==(const gc_allocator&, const gc_allocator&) ++{ ++ return true; ++} ++ ++template ++inline bool operator!=(const gc_allocator&, const gc_allocator&) ++{ ++ return false; ++} ++ ++/* ++ * And the public traceable_allocator class. ++ */ ++ ++// Note that we currently don't specialize the pointer-free case, since a ++// pointer-free traceable container doesn't make that much sense, ++// though it could become an issue due to abstraction boundaries. ++template ++class traceable_allocator { ++public: ++ typedef size_t size_type; ++ typedef ptrdiff_t difference_type; ++ typedef GC_Tp* pointer; ++ typedef const GC_Tp* const_pointer; ++ typedef GC_Tp& reference; ++ typedef const GC_Tp& const_reference; ++ typedef GC_Tp value_type; ++ ++ template struct rebind { ++ typedef traceable_allocator other; ++ }; ++ ++ traceable_allocator() throw() {} ++# ifndef _MSC_VER ++ traceable_allocator(const traceable_allocator&) throw() {} ++# endif ++ template traceable_allocator ++ (const traceable_allocator&) throw() {} ++ ~traceable_allocator() throw() {} ++ ++ pointer address(reference GC_x) const { return &GC_x; } ++ const_pointer address(const_reference GC_x) const { return &GC_x; } ++ ++ // GC_n is permitted to be 0. The C++ standard says nothing about what ++ // the return value is when GC_n == 0. ++ GC_Tp* allocate(size_type GC_n, const void* = 0) { ++ return static_cast(GC_MALLOC_UNCOLLECTABLE(GC_n * sizeof(GC_Tp))); ++ } ++ ++ // __p is not permitted to be a null pointer. ++ void deallocate(pointer __p, size_type GC_n) ++ { GC_FREE(__p); } ++ ++ size_type max_size() const throw() ++ { return size_t(-1) / sizeof(GC_Tp); } ++ ++ void construct(pointer __p, const GC_Tp& __val) { new(__p) GC_Tp(__val); } ++ void destroy(pointer __p) { __p->~GC_Tp(); } ++}; ++ ++template<> ++class traceable_allocator { ++ typedef size_t size_type; ++ typedef ptrdiff_t difference_type; ++ typedef void* pointer; ++ typedef const void* const_pointer; ++ typedef void value_type; ++ ++ template struct rebind { ++ typedef traceable_allocator other; ++ }; ++}; ++ ++ ++template ++inline bool operator==(const traceable_allocator&, const traceable_allocator&) ++{ ++ return true; ++} ++ ++template ++inline bool operator!=(const traceable_allocator&, const traceable_allocator&) ++{ ++ return false; ++} ++ +diff -urNb boehm-gc/include/gc_config_macros.h boehm-gc/include/gc_config_macros.h +--- boehm-gc/include/gc_config_macros.h Wed Dec 31 16:00:00 1969 ++++ boehm-gc/include/gc_config_macros.h Mon May 26 13:28:19 2003 +@@ -0,0 +1,142 @@ ++/* ++ * This should never be included directly. It is included only from gc.h. ++ * We separate it only to make gc.h more suitable as documentation. ++ * ++ * Some tests for old macros. These violate our namespace rules and will ++ * disappear shortly. Use the GC_ names. ++ */ ++#if defined(SOLARIS_THREADS) || defined(_SOLARIS_THREADS) ++# define GC_SOLARIS_THREADS ++#endif ++#if defined(_SOLARIS_PTHREADS) ++# define GC_SOLARIS_PTHREADS ++#endif ++#if defined(IRIX_THREADS) ++# define GC_IRIX_THREADS ++#endif ++#if defined(DGUX_THREADS) ++# if !defined(GC_DGUX386_THREADS) ++# define GC_DGUX386_THREADS ++# endif ++#endif ++#if defined(HPUX_THREADS) ++# define GC_HPUX_THREADS ++#endif ++#if defined(OSF1_THREADS) ++# define GC_OSF1_THREADS ++#endif ++#if defined(LINUX_THREADS) ++# define GC_LINUX_THREADS ++#endif ++#if defined(WIN32_THREADS) ++# define GC_WIN32_THREADS ++#endif ++#if defined(USE_LD_WRAP) ++# define GC_USE_LD_WRAP ++#endif ++ ++#if !defined(_REENTRANT) && (defined(GC_SOLARIS_THREADS) \ ++ || defined(GC_SOLARIS_PTHREADS) \ ++ || defined(GC_HPUX_THREADS) \ ++ || defined(GC_LINUX_THREADS)) ++# define _REENTRANT ++ /* Better late than never. This fails if system headers that */ ++ /* depend on this were previously included. */ ++#endif ++ ++#if defined(GC_DGUX386_THREADS) && !defined(_POSIX4A_DRAFT10_SOURCE) ++# define _POSIX4A_DRAFT10_SOURCE 1 ++#endif ++ ++# if defined(GC_SOLARIS_PTHREADS) || defined(GC_FREEBSD_THREADS) || \ ++ defined(GC_IRIX_THREADS) || defined(GC_LINUX_THREADS) || \ ++ defined(GC_HPUX_THREADS) || defined(GC_OSF1_THREADS) || \ ++ defined(GC_DGUX386_THREADS) || defined(GC_DARWIN_THREADS) || \ ++ (defined(GC_WIN32_THREADS) && defined(__CYGWIN32__)) ++# define GC_PTHREADS ++# endif ++ ++#if defined(GC_THREADS) && !defined(GC_PTHREADS) ++# if defined(__linux__) ++# define GC_LINUX_THREADS ++# define GC_PTHREADS ++# endif ++# if !defined(LINUX) && (defined(_PA_RISC1_1) || defined(_PA_RISC2_0) \ ++ || defined(hppa) || defined(__HPPA)) ++# define GC_HPUX_THREADS ++# define GC_PTHREADS ++# endif ++# if !defined(__linux__) && (defined(__alpha) || defined(__alpha__)) ++# define GC_OSF1_THREADS ++# define GC_PTHREADS ++# endif ++# if defined(__mips) && !defined(__linux__) ++# define GC_IRIX_THREADS ++# define GC_PTHREADS ++# endif ++# if defined(__sparc) && !defined(__linux__) ++# define GC_SOLARIS_PTHREADS ++# define GC_PTHREADS ++# endif ++# if defined(__APPLE__) && defined(__MACH__) && defined(__ppc__) ++# define GC_DARWIN_THREADS ++# define GC_PTHREADS ++# endif ++# if !defined(GC_PTHREADS) && defined(__FreeBSD__) ++# define GC_FREEBSD_THREADS ++# define GC_PTHREADS ++# endif ++# if defined(DGUX) && (defined(i386) || defined(__i386__)) ++# define GC_DGUX386_THREADS ++# define GC_PTHREADS ++# endif ++#endif /* GC_THREADS */ ++ ++#if defined(GC_THREADS) && !defined(GC_PTHREADS) && defined(MSWIN32) ++# define GC_WIN32_THREADS ++#endif ++ ++#if defined(GC_SOLARIS_PTHREADS) && !defined(GC_SOLARIS_THREADS) ++# define GC_SOLARIS_THREADS ++#endif ++ ++# define __GC ++# include ++# ifdef _WIN32_WCE ++/* Yet more kluges for WinCE */ ++# include /* size_t is defined here */ ++ typedef long ptrdiff_t; /* ptrdiff_t is not defined */ ++# endif ++ ++#if defined(_DLL) && !defined(GC_NOT_DLL) && !defined(GC_DLL) ++# define GC_DLL ++#endif ++ ++#if defined(__MINGW32__) && defined(GC_DLL) ++# ifdef GC_BUILD ++# define GC_API __declspec(dllexport) ++# else ++# define GC_API __declspec(dllimport) ++# endif ++#endif ++ ++#if (defined(__DMC__) || defined(_MSC_VER)) && defined(GC_DLL) ++# ifdef GC_BUILD ++# define GC_API extern __declspec(dllexport) ++# else ++# define GC_API __declspec(dllimport) ++# endif ++#endif ++ ++#if defined(__WATCOMC__) && defined(GC_DLL) ++# ifdef GC_BUILD ++# define GC_API extern __declspec(dllexport) ++# else ++# define GC_API extern __declspec(dllimport) ++# endif ++#endif ++ ++#ifndef GC_API ++#define GC_API extern ++#endif ++ +diff -urNb boehm-gc/include/gc_cpp.h boehm-gc/include/gc_cpp.h +--- boehm-gc/include/gc_cpp.h Fri Aug 17 18:04:43 2001 ++++ boehm-gc/include/gc_cpp.h Mon May 26 13:28:19 2003 +@@ -134,7 +134,9 @@ + #include "gc.h" + + #ifndef THINK_CPLUS +-#define _cdecl ++# define GC_cdecl ++#else ++# define GC_cdecl _cdecl + #endif + + #if ! defined( GC_NO_OPERATOR_NEW_ARRAY ) \ +@@ -159,12 +161,22 @@ + class gc {public: + inline void* operator new( size_t size ); + inline void* operator new( size_t size, GCPlacement gcp ); ++ inline void* operator new( size_t size, void *p ); ++ /* Must be redefined here, since the other overloadings */ ++ /* hide the global definition. */ + inline void operator delete( void* obj ); ++# ifndef __BORLANDC__ /* Confuses the Borland compiler. */ ++ inline void operator delete( void*, void* ); ++# endif + + #ifdef GC_OPERATOR_NEW_ARRAY + inline void* operator new[]( size_t size ); + inline void* operator new[]( size_t size, GCPlacement gcp ); ++ inline void* operator new[]( size_t size, void *p ); + inline void operator delete[]( void* obj ); ++# ifndef __BORLANDC__ ++ inline void gc::operator delete[]( void*, void* ); ++# endif + #endif /* GC_OPERATOR_NEW_ARRAY */ + }; + /* +@@ -176,7 +188,7 @@ + inline gc_cleanup(); + inline virtual ~gc_cleanup(); + private: +- inline static void _cdecl cleanup( void* obj, void* clientData );}; ++ inline static void GC_cdecl cleanup( void* obj, void* clientData );}; + /* + Instances of classes derived from "gc_cleanup" will be allocated + in the collected heap by default. When the collector discovers an +@@ -211,7 +223,6 @@ + classes derived from "gc_cleanup" or containing members derived + from "gc_cleanup". */ + +-#ifdef GC_OPERATOR_NEW_ARRAY + + #ifdef _MSC_VER + /** This ensures that the system default operator new[] doesn't get +@@ -220,42 +231,24 @@ + * There seems to be really redirect new in this environment without + * including this everywhere. + */ +- inline void *operator new[]( size_t size ) +- { +- return GC_MALLOC_UNCOLLECTABLE( size ); +- } +- +- inline void operator delete[](void* obj) +- { +- GC_FREE(obj); +- }; ++ void *operator new[]( size_t size ); + +- inline void* operator new( size_t size) +- { +- return GC_MALLOC_UNCOLLECTABLE( size); +- }; ++ void operator delete[](void* obj); + +- inline void operator delete(void* obj) +- { +- GC_FREE(obj); +- }; ++ void* operator new( size_t size); + ++ void operator delete(void* obj); + +-// This new operator is used by VC++ in case of Debug builds ! +- inline void* operator new( size_t size, ++ // This new operator is used by VC++ in case of Debug builds ! ++ void* operator new( size_t size, + int ,//nBlockUse, + const char * szFileName, +- int nLine +- ) { +-# ifndef GC_DEBUG +- return GC_malloc_uncollectable( size ); +-# else +- return GC_debug_malloc_uncollectable(size, szFileName, nLine); +-# endif +- } +- ++ int nLine ); + #endif /* _MSC_VER */ + ++ ++#ifdef GC_OPERATOR_NEW_ARRAY ++ + inline void* operator new[]( + size_t size, + GCPlacement gcp, +@@ -283,9 +276,15 @@ + else + return GC_MALLOC_UNCOLLECTABLE( size );} + ++inline void* gc::operator new( size_t size, void *p ) { ++ return p;} ++ + inline void gc::operator delete( void* obj ) { + GC_FREE( obj );} + ++#ifndef __BORLANDC__ ++ inline void gc::operator delete( void*, void* ) {} ++#endif + + #ifdef GC_OPERATOR_NEW_ARRAY + +@@ -295,14 +294,21 @@ + inline void* gc::operator new[]( size_t size, GCPlacement gcp ) { + return gc::operator new( size, gcp );} + ++inline void* gc::operator new[]( size_t size, void *p ) { ++ return p;} ++ + inline void gc::operator delete[]( void* obj ) { + gc::operator delete( obj );} + ++#ifndef __BORLANDC__ ++ inline void gc::operator delete[]( void*, void* ) {} ++#endif ++ + #endif /* GC_OPERATOR_NEW_ARRAY */ + + + inline gc_cleanup::~gc_cleanup() { +- GC_REGISTER_FINALIZER_IGNORE_SELF( GC_base(this), 0, 0, 0, 0 );} ++ GC_register_finalizer_ignore_self( GC_base(this), 0, 0, 0, 0 );} + + inline void gc_cleanup::cleanup( void* obj, void* displ ) { + ((gc_cleanup*) ((char*) obj + (ptrdiff_t) displ))->~gc_cleanup();} +diff -urNb boehm-gc/include/gc_local_alloc.h boehm-gc/include/gc_local_alloc.h +--- boehm-gc/include/gc_local_alloc.h Fri Aug 17 11:30:50 2001 ++++ boehm-gc/include/gc_local_alloc.h Mon May 26 13:28:19 2003 +@@ -33,6 +33,9 @@ + * -DTHREAD_LOCAL_ALLOC, which is currently supported only on Linux. + * + * The debugging allocators use standard, not thread-local allocation. ++ * ++ * These routines normally require an explicit call to GC_init(), though ++ * that may be done from a constructor function. + */ + + #ifndef GC_LOCAL_ALLOC_H +diff -urNb boehm-gc/include/gc_mark.h boehm-gc/include/gc_mark.h +--- boehm-gc/include/gc_mark.h Fri Aug 17 11:30:50 2001 ++++ boehm-gc/include/gc_mark.h Mon May 26 13:28:19 2003 +@@ -129,7 +129,9 @@ + /* be reserved for exceptional cases. That will ensure that */ + /* performance of this call is not extremely performance critical. */ + /* (Otherwise we would need to inline GC_mark_and_push completely, */ +-/* which would tie the client code to a fixed colllector version.) */ ++/* which would tie the client code to a fixed collector version.) */ ++/* Note that mark procedures should explicitly call FIXUP_POINTER() */ ++/* if required. */ + struct GC_ms_entry *GC_mark_and_push + GC_PROTO((GC_PTR obj, + struct GC_ms_entry * mark_stack_ptr, +diff -urNb boehm-gc/include/gc_pthread_redirects.h boehm-gc/include/gc_pthread_redirects.h +--- boehm-gc/include/gc_pthread_redirects.h Tue Oct 16 21:55:28 2001 ++++ boehm-gc/include/gc_pthread_redirects.h Mon May 26 13:28:19 2003 +@@ -52,15 +52,21 @@ + int GC_pthread_create(pthread_t *new_thread, + const pthread_attr_t *attr, + void *(*start_routine)(void *), void *arg); ++#ifndef GC_DARWIN_THREADS + int GC_pthread_sigmask(int how, const sigset_t *set, sigset_t *oset); ++#endif + int GC_pthread_join(pthread_t thread, void **retval); + int GC_pthread_detach(pthread_t thread); + + # define pthread_create GC_pthread_create ++#ifndef GC_DARWIN_THREADS + # define pthread_sigmask GC_pthread_sigmask ++#endif + # define pthread_join GC_pthread_join + # define pthread_detach GC_pthread_detach ++#ifndef GC_DARWIN_THREADS + # define dlopen GC_dlopen ++#endif + + #endif /* GC_xxxxx_THREADS */ + +diff -urNb boehm-gc/include/gc_typed.h boehm-gc/include/gc_typed.h +--- boehm-gc/include/gc_typed.h Fri Aug 17 11:30:50 2001 ++++ boehm-gc/include/gc_typed.h Mon May 26 13:28:19 2003 +@@ -29,14 +29,21 @@ + # include "gc.h" + # endif + ++#ifdef __cplusplus ++ extern "C" { ++#endif + typedef GC_word * GC_bitmap; + /* The least significant bit of the first word is one if */ + /* the first word in the object may be a pointer. */ + ++# define GC_WORDSZ (8*sizeof(GC_word)) + # define GC_get_bit(bm, index) \ +- (((bm)[divWORDSZ(index)] >> modWORDSZ(index)) & 1) ++ (((bm)[index/GC_WORDSZ] >> (index%GC_WORDSZ)) & 1) + # define GC_set_bit(bm, index) \ +- (bm)[divWORDSZ(index)] |= (word)1 << modWORDSZ(index) ++ (bm)[index/GC_WORDSZ] |= ((GC_word)1 << (index%GC_WORDSZ)) ++# define GC_WORD_OFFSET(t, f) (offsetof(t,f)/sizeof(GC_word)) ++# define GC_WORD_LEN(t) (sizeof(t)/ sizeof(GC_word)) ++# define GC_BITMAP_SIZE(t) ((GC_WORD_LEN(t) + GC_WORDSZ-1)/GC_WORDSZ) + + typedef GC_word GC_descr; + +@@ -57,6 +64,16 @@ + /* is intended to be called once per type, not once */ + /* per allocation. */ + ++/* It is possible to generate a descriptor for a C type T with */ ++/* word aligned pointer fields f1, f2, ... as follows: */ ++/* */ ++/* GC_descr T_descr; ++/* GC_word T_bitmap[GC_BITMAP_SIZE(T)] = {0}; */ ++/* GC_set_bit(T_bitmap, GC_WORD_OFFSET(T,f1)); */ ++/* GC_set_bit(T_bitmap, GC_WORD_OFFSET(T,f2)); */ ++/* ... */ ++/* T_descr = GC_make_descriptor(T_bitmap, GC_WORD_LEN(T)); */ ++ + GC_API GC_PTR GC_malloc_explicitly_typed + GC_PROTO((size_t size_in_bytes, GC_descr d)); + /* Allocate an object whose layout is described by d. */ +@@ -79,15 +96,18 @@ + /* Returned object is cleared. */ + + #ifdef GC_DEBUG +-# define GC_MALLOC_EXPLICTLY_TYPED(bytes, d) GC_MALLOC(bytes) +-# define GC_CALLOC_EXPLICTLY_TYPED(n, bytes, d) GC_MALLOC(n*bytes) ++# define GC_MALLOC_EXPLICITLY_TYPED(bytes, d) GC_MALLOC(bytes) ++# define GC_CALLOC_EXPLICITLY_TYPED(n, bytes, d) GC_MALLOC(n*bytes) + #else +-# define GC_MALLOC_EXPLICTLY_TYPED(bytes, d) \ ++# define GC_MALLOC_EXPLICITLY_TYPED(bytes, d) \ + GC_malloc_explicitly_typed(bytes, d) +-# define GC_CALLOC_EXPLICTLY_TYPED(n, bytes, d) \ ++# define GC_CALLOC_EXPLICITLY_TYPED(n, bytes, d) \ + GC_calloc_explicitly_typed(n, bytes, d) + #endif /* !GC_DEBUG */ + ++#ifdef __cplusplus ++ } /* matches extern "C" */ ++#endif + + #endif /* _GC_TYPED_H */ + +diff -urNb boehm-gc/include/new_gc_alloc.h boehm-gc/include/new_gc_alloc.h +--- boehm-gc/include/new_gc_alloc.h Tue Oct 16 02:01:38 2001 ++++ boehm-gc/include/new_gc_alloc.h Mon May 26 13:28:19 2003 +@@ -64,6 +64,14 @@ + #endif + #endif + ++/* A hack to deal with gcc 3.1. If you are using gcc3.1 and later, */ ++/* you should probably really use gc_allocator.h instead. */ ++#if defined (__GNUC__) && \ ++ (__GNUC > 3 || (__GNUC__ == 3 && (__GNUC_MINOR__ >= 1))) ++# define simple_alloc __simple_alloc ++#endif ++ ++ + + #define GC_ALLOC_H + +diff -urNb boehm-gc/include/private/darwin_semaphore.h boehm-gc/include/private/darwin_semaphore.h +--- boehm-gc/include/private/darwin_semaphore.h Wed Dec 31 16:00:00 1969 ++++ boehm-gc/include/private/darwin_semaphore.h Mon May 26 13:28:24 2003 +@@ -0,0 +1,68 @@ ++#ifndef GC_DARWIN_SEMAPHORE_H ++#define GC_DARWIN_SEMAPHORE_H ++ ++#if !defined(GC_DARWIN_THREADS) ++#error darwin_semaphore.h included with GC_DARWIN_THREADS not defined ++#endif ++ ++/* ++ This is a very simple semaphore implementation for darwin. It ++ is implemented in terms of pthreads calls so it isn't async signal ++ safe. This isn't a problem because signals aren't used to ++ suspend threads on darwin. ++*/ ++ ++typedef struct { ++ pthread_mutex_t mutex; ++ pthread_cond_t cond; ++ int value; ++} sem_t; ++ ++static int sem_init(sem_t *sem, int pshared, int value) { ++ int ret; ++ if(pshared) ++ GC_abort("sem_init with pshared set"); ++ sem->value = value; ++ ++ ret = pthread_mutex_init(&sem->mutex,NULL); ++ if(ret < 0) return -1; ++ ret = pthread_cond_init(&sem->cond,NULL); ++ if(ret < 0) return -1; ++ return 0; ++} ++ ++static int sem_post(sem_t *sem) { ++ if(pthread_mutex_lock(&sem->mutex) < 0) ++ return -1; ++ sem->value++; ++ if(pthread_cond_signal(&sem->cond) < 0) { ++ pthread_mutex_unlock(&sem->mutex); ++ return -1; ++ } ++ if(pthread_mutex_unlock(&sem->mutex) < 0) ++ return -1; ++ return 0; ++} ++ ++static int sem_wait(sem_t *sem) { ++ if(pthread_mutex_lock(&sem->mutex) < 0) ++ return -1; ++ while(sem->value == 0) { ++ pthread_cond_wait(&sem->cond,&sem->mutex); ++ } ++ sem->value--; ++ if(pthread_mutex_unlock(&sem->mutex) < 0) ++ return -1; ++ return 0; ++} ++ ++static int sem_destroy(sem_t *sem) { ++ int ret; ++ ret = pthread_cond_destroy(&sem->cond); ++ if(ret < 0) return -1; ++ ret = pthread_mutex_destroy(&sem->mutex); ++ if(ret < 0) return -1; ++ return 0; ++} ++ ++#endif +diff -urNb boehm-gc/include/private/darwin_stop_world.h boehm-gc/include/private/darwin_stop_world.h +--- boehm-gc/include/private/darwin_stop_world.h Wed Dec 31 16:00:00 1969 ++++ boehm-gc/include/private/darwin_stop_world.h Mon May 26 13:28:24 2003 +@@ -0,0 +1,15 @@ ++#ifndef GC_DARWIN_STOP_WORLD_H ++#define GC_DARWIN_STOP_WORLD_H ++ ++#if !defined(GC_DARWIN_THREADS) ++#error darwin_stop_world.h included without GC_DARWIN_THREADS defined ++#endif ++ ++#include ++#include ++ ++struct thread_stop_info { ++ mach_port_t mach_thread; ++}; ++ ++#endif +diff -urNb boehm-gc/include/private/dbg_mlc.h boehm-gc/include/private/dbg_mlc.h +--- boehm-gc/include/private/dbg_mlc.h Mon Feb 11 20:37:57 2002 ++++ boehm-gc/include/private/dbg_mlc.h Mon May 26 13:28:24 2003 +@@ -115,16 +115,24 @@ + + #ifdef SHORT_DBG_HDRS + # define DEBUG_BYTES (sizeof (oh)) ++# define UNCOLLECTABLE_DEBUG_BYTES DEBUG_BYTES + #else + /* Add space for END_FLAG, but use any extra space that was already */ + /* added to catch off-the-end pointers. */ +-# define DEBUG_BYTES (sizeof (oh) + sizeof (word) - EXTRA_BYTES) ++ /* For uncollectable objects, the extra byte is not added. */ ++# define UNCOLLECTABLE_DEBUG_BYTES (sizeof (oh) + sizeof (word)) ++# define DEBUG_BYTES (UNCOLLECTABLE_DEBUG_BYTES - EXTRA_BYTES) + #endif + #define USR_PTR_FROM_BASE(p) ((ptr_t)(p) + sizeof(oh)) + + /* Round bytes to words without adding extra byte at end. */ + #define SIMPLE_ROUNDED_UP_WORDS(n) BYTES_TO_WORDS((n) + WORDS_TO_BYTES(1) - 1) + ++/* ADD_CALL_CHAIN stores a (partial) call chain into an object */ ++/* header. It may be called with or without the allocation */ ++/* lock. */ ++/* PRINT_CALL_CHAIN prints the call chain stored in an object */ ++/* to stderr. It requires that we do not hold the lock. */ + #ifdef SAVE_CALL_CHAIN + # define ADD_CALL_CHAIN(base, ra) GC_save_callers(((oh *)(base)) -> oh_ci) + # define PRINT_CALL_CHAIN(base) GC_print_callers(((oh *)(base)) -> oh_ci) +diff -urNb boehm-gc/include/private/gc_hdrs.h boehm-gc/include/private/gc_hdrs.h +--- boehm-gc/include/private/gc_hdrs.h Fri Aug 17 18:04:43 2001 ++++ boehm-gc/include/private/gc_hdrs.h Mon May 26 13:28:24 2003 +@@ -70,7 +70,7 @@ + #define ADVANCE(p, hhdr, source) \ + { \ + hdr * new_hdr = GC_invalid_header; \ +- p = GC_FIND_START(p, hhdr, &new_hdr, (word)source); \ ++ p = GC_find_start(p, hhdr, &new_hdr); \ + hhdr = new_hdr; \ + } + +diff -urNb boehm-gc/include/private/gc_locks.h boehm-gc/include/private/gc_locks.h +--- boehm-gc/include/private/gc_locks.h Fri Sep 27 13:40:06 2002 ++++ boehm-gc/include/private/gc_locks.h Mon May 26 13:28:24 2003 +@@ -145,23 +145,24 @@ + # if defined(POWERPC) + inline static int GC_test_and_set(volatile unsigned int *addr) { + int oldval; +- int temp = 1; // locked value ++ int temp = 1; /* locked value */ + + __asm__ __volatile__( +- "1:\tlwarx %0,0,%3\n" // load and reserve +- "\tcmpwi %0, 0\n" // if load is +- "\tbne 2f\n" // non-zero, return already set +- "\tstwcx. %2,0,%1\n" // else store conditional +- "\tbne- 1b\n" // retry if lost reservation +- "2:\t\n" // oldval is zero if we set ++ "1:\tlwarx %0,0,%3\n" /* load and reserve */ ++ "\tcmpwi %0, 0\n" /* if load is */ ++ "\tbne 2f\n" /* non-zero, return already set */ ++ "\tstwcx. %2,0,%1\n" /* else store conditional */ ++ "\tbne- 1b\n" /* retry if lost reservation */ ++ "\tsync\n" /* import barrier */ ++ "2:\t\n" /* oldval is zero if we set */ + : "=&r"(oldval), "=p"(addr) + : "r"(temp), "1"(addr) +- : "memory"); +- return (int)oldval; ++ : "cr0","memory"); ++ return oldval; + } + # define GC_TEST_AND_SET_DEFINED + inline static void GC_clear(volatile unsigned int *addr) { +- __asm__ __volatile__("eieio" ::: "memory"); ++ __asm__ __volatile__("eieio" : : : "memory"); + *(addr) = 0; + } + # define GC_CLEAR_DEFINED +@@ -191,8 +192,11 @@ + return oldvalue; + } + # define GC_TEST_AND_SET_DEFINED +- /* Should probably also define GC_clear, since it needs */ +- /* a memory barrier ?? */ ++ inline static void GC_clear(volatile unsigned int *addr) { ++ __asm__ __volatile__("mb" : : : "memory"); ++ *(addr) = 0; ++ } ++# define GC_CLEAR_DEFINED + # endif /* ALPHA */ + # ifdef ARM32 + inline static int GC_test_and_set(volatile unsigned int *addr) { +@@ -224,8 +228,16 @@ + # endif + # endif /* __GNUC__ */ + # if (defined(ALPHA) && !defined(__GNUC__)) +-# define GC_test_and_set(addr) __cxx_test_and_set_atomic(addr, 1) ++# ifndef OSF1 ++ --> We currently assume that if gcc is not used, we are ++ --> running under Tru64. ++# endif ++# include ++# include ++# define GC_test_and_set(addr) __ATOMIC_EXCH_LONG(addr, 1) + # define GC_TEST_AND_SET_DEFINED ++# define GC_clear(addr) { asm("mb"); *(volatile unsigned *)addr = 0; } ++# define GC_CLEAR_DEFINED + # endif + # if defined(MSWIN32) + # define GC_test_and_set(addr) InterlockedExchange((LPLONG)addr,1) +@@ -238,7 +250,11 @@ + # define GC_TEST_AND_SET_DEFINED + # elif __mips < 3 || !(defined (_ABIN32) || defined(_ABI64)) \ + || !defined(_COMPILER_VERSION) || _COMPILER_VERSION < 700 +-# define GC_test_and_set(addr) test_and_set(addr, 1) ++# ifdef __GNUC__ ++# define GC_test_and_set(addr) _test_and_set(addr,1) ++# else ++# define GC_test_and_set(addr) test_and_set(addr,1) ++# endif + # else + # define GC_test_and_set(addr) __test_and_set(addr,1) + # define GC_clear(addr) __lock_release(addr); +@@ -279,7 +295,7 @@ + # endif + + # if defined(GC_PTHREADS) && !defined(GC_SOLARIS_THREADS) \ +- && !defined(GC_IRIX_THREADS) ++ && !defined(GC_IRIX_THREADS) && !defined(GC_WIN32_THREADS) + # define NO_THREAD (pthread_t)(-1) + # include + # if defined(PARALLEL_MARK) +@@ -310,12 +326,12 @@ + { + char result; + __asm__ __volatile__("lock; cmpxchgl %2, %0; setz %1" +- : "=m"(*(addr)), "=r"(result) +- : "r" (new_val), "0"(*(addr)), "a"(old) : "memory"); ++ : "+m"(*(addr)), "=r"(result) ++ : "r" (new_val), "a"(old) : "memory"); + return (GC_bool) result; + } + # endif /* !GENERIC_COMPARE_AND_SWAP */ +- inline static void GC_memory_write_barrier() ++ inline static void GC_memory_barrier() + { + /* We believe the processor ensures at least processor */ + /* consistent ordering. Thus a compiler barrier */ +@@ -323,6 +339,37 @@ + __asm__ __volatile__("" : : : "memory"); + } + # endif /* I386 */ ++ ++# if defined(POWERPC) ++# if !defined(GENERIC_COMPARE_AND_SWAP) ++ /* Returns TRUE if the comparison succeeded. */ ++ inline static GC_bool GC_compare_and_exchange(volatile GC_word *addr, ++ GC_word old, GC_word new_val) ++ { ++ int result, dummy; ++ __asm__ __volatile__( ++ "1:\tlwarx %0,0,%5\n" ++ "\tcmpw %0,%4\n" ++ "\tbne 2f\n" ++ "\tstwcx. %3,0,%2\n" ++ "\tbne- 1b\n" ++ "\tsync\n" ++ "\tli %1, 1\n" ++ "\tb 3f\n" ++ "2:\tli %1, 0\n" ++ "3:\t\n" ++ : "=&r" (dummy), "=r" (result), "=p" (addr) ++ : "r" (new_val), "r" (old), "2"(addr) ++ : "cr0","memory"); ++ return (GC_bool) result; ++ } ++# endif /* !GENERIC_COMPARE_AND_SWAP */ ++ inline static void GC_memory_barrier() ++ { ++ __asm__ __volatile__("sync" : : : "memory"); ++ } ++# endif /* POWERPC */ ++ + # if defined(IA64) + # if !defined(GENERIC_COMPARE_AND_SWAP) + inline static GC_bool GC_compare_and_exchange(volatile GC_word *addr, +@@ -337,12 +384,52 @@ + # endif /* !GENERIC_COMPARE_AND_SWAP */ + # if 0 + /* Shouldn't be needed; we use volatile stores instead. */ +- inline static void GC_memory_write_barrier() ++ inline static void GC_memory_barrier() + { + __asm__ __volatile__("mf" : : : "memory"); + } + # endif /* 0 */ + # endif /* IA64 */ ++# if defined(ALPHA) ++# if !defined(GENERIC_COMPARE_AND_SWAP) ++# if defined(__GNUC__) ++ inline static GC_bool GC_compare_and_exchange(volatile GC_word *addr, ++ GC_word old, GC_word new_val) ++ { ++ unsigned long was_equal; ++ unsigned long temp; ++ ++ __asm__ __volatile__( ++ "1: ldq_l %0,%1\n" ++ " cmpeq %0,%4,%2\n" ++ " mov %3,%0\n" ++ " beq %2,2f\n" ++ " stq_c %0,%1\n" ++ " beq %0,1b\n" ++ "2:\n" ++ " mb\n" ++ :"=&r" (temp), "=m" (*addr), "=&r" (was_equal) ++ : "r" (new_val), "Ir" (old) ++ :"memory"); ++ return was_equal; ++ } ++# else /* !__GNUC__ */ ++ inline static GC_bool GC_compare_and_exchange(volatile GC_word *addr, ++ GC_word old, GC_word new_val) ++ { ++ return __CMP_STORE_QUAD(addr, old, new_val, addr); ++ } ++# endif /* !__GNUC__ */ ++# endif /* !GENERIC_COMPARE_AND_SWAP */ ++# ifdef __GNUC__ ++ inline static void GC_memory_barrier() ++ { ++ __asm__ __volatile__("mb" : : : "memory"); ++ } ++# else ++# define GC_memory_barrier() asm("mb") ++# endif /* !__GNUC__ */ ++# endif /* ALPHA */ + # if defined(S390) + # if !defined(GENERIC_COMPARE_AND_SWAP) + inline static GC_bool GC_compare_and_exchange(volatile C_word *addr, +@@ -434,8 +521,12 @@ + { GC_ASSERT(I_HOLD_LOCK()); UNSET_LOCK_HOLDER(); \ + pthread_mutex_unlock(&GC_allocate_ml); } + # else /* !GC_ASSERTIONS */ ++# if defined(NO_PTHREAD_TRYLOCK) ++# define LOCK() GC_lock(); ++# else /* !defined(NO_PTHREAD_TRYLOCK) */ + # define LOCK() \ + { if (0 != pthread_mutex_trylock(&GC_allocate_ml)) GC_lock(); } ++# endif + # define UNLOCK() pthread_mutex_unlock(&GC_allocate_ml) + # endif /* !GC_ASSERTIONS */ + # endif /* USE_PTHREAD_LOCKS */ +@@ -478,11 +569,18 @@ + } + # define EXIT_GC() GC_collecting = 0; + # endif /* GC_IRIX_THREADS */ +-# ifdef GC_WIN32_THREADS ++# if defined(GC_WIN32_THREADS) ++# if defined(GC_PTHREADS) ++# include ++ extern pthread_mutex_t GC_allocate_ml; ++# define LOCK() pthread_mutex_lock(&GC_allocate_ml) ++# define UNLOCK() pthread_mutex_unlock(&GC_allocate_ml) ++# else + # include + GC_API CRITICAL_SECTION GC_allocate_ml; + # define LOCK() EnterCriticalSection(&GC_allocate_ml); + # define UNLOCK() LeaveCriticalSection(&GC_allocate_ml); ++# endif + # endif + # ifndef SET_LOCK_HOLDER + # define SET_LOCK_HOLDER() +diff -urNb boehm-gc/include/private/gc_pmark.h boehm-gc/include/private/gc_pmark.h +--- boehm-gc/include/private/gc_pmark.h Mon Feb 11 20:37:57 2002 ++++ boehm-gc/include/private/gc_pmark.h Mon May 26 13:28:24 2003 +@@ -137,7 +137,7 @@ + #ifdef __STDC__ + # ifdef PRINT_BLACK_LIST + ptr_t GC_find_start(ptr_t current, hdr *hhdr, hdr **new_hdr_p, +- ptr_t source); ++ word source); + # else + ptr_t GC_find_start(ptr_t current, hdr *hhdr, hdr **new_hdr_p); + # endif +@@ -145,7 +145,7 @@ + ptr_t GC_find_start(); + #endif + +-mse *GC_signal_mark_stack_overflow(mse *msp); ++mse * GC_signal_mark_stack_overflow GC_PROTO((mse *msp)); + + # ifdef GATHERSTATS + # define ADD_TO_ATOMIC(sz) GC_atomic_in_use += (sz) +@@ -174,14 +174,6 @@ + } \ + } + +-#ifdef PRINT_BLACK_LIST +-# define GC_FIND_START(current, hhdr, new_hdr_p, source) \ +- GC_find_start(current, hhdr, new_hdr_p, source) +-#else +-# define GC_FIND_START(current, hhdr, new_hdr_p, source) \ +- GC_find_start(current, hhdr, new_hdr_p) +-#endif +- + /* Push the contents of current onto the mark stack if it is a valid */ + /* ptr to a currently unmarked object. Mark it. */ + /* If we assumed a standard-conforming compiler, we could probably */ +@@ -195,8 +187,7 @@ + GET_HDR(my_current, my_hhdr); \ + if (IS_FORWARDING_ADDR_OR_NIL(my_hhdr)) { \ + hdr * new_hdr = GC_invalid_header; \ +- my_current = GC_FIND_START(my_current, my_hhdr, \ +- &new_hdr, (word)source); \ ++ my_current = GC_find_start(my_current, my_hhdr, &new_hdr); \ + my_hhdr = new_hdr; \ + } \ + PUSH_CONTENTS_HDR(my_current, mark_stack_top, mark_stack_limit, \ +@@ -290,21 +281,39 @@ + + /* + * Push a single value onto mark stack. Mark from the object pointed to by p. ++ * Invoke FIXUP_POINTER(p) before any further processing. + * P is considered valid even if it is an interior pointer. + * Previously marked objects are not pushed. Hence we make progress even + * if the mark stack overflows. + */ ++ ++# if NEED_FIXUP_POINTER ++ /* Try both the raw version and the fixed up one. */ + # define GC_PUSH_ONE_STACK(p, source) \ + if ((ptr_t)(p) >= (ptr_t)GC_least_plausible_heap_addr \ + && (ptr_t)(p) < (ptr_t)GC_greatest_plausible_heap_addr) { \ + PUSH_ONE_CHECKED_STACK(p, source); \ ++ } \ ++ FIXUP_POINTER(p); \ ++ if ((ptr_t)(p) >= (ptr_t)GC_least_plausible_heap_addr \ ++ && (ptr_t)(p) < (ptr_t)GC_greatest_plausible_heap_addr) { \ ++ PUSH_ONE_CHECKED_STACK(p, source); \ + } ++# else /* !NEED_FIXUP_POINTER */ ++# define GC_PUSH_ONE_STACK(p, source) \ ++ if ((ptr_t)(p) >= (ptr_t)GC_least_plausible_heap_addr \ ++ && (ptr_t)(p) < (ptr_t)GC_greatest_plausible_heap_addr) { \ ++ PUSH_ONE_CHECKED_STACK(p, source); \ ++ } ++# endif ++ + + /* + * As above, but interior pointer recognition as for + * normal for heap pointers. + */ + # define GC_PUSH_ONE_HEAP(p,source) \ ++ FIXUP_POINTER(p); \ + if ((ptr_t)(p) >= (ptr_t)GC_least_plausible_heap_addr \ + && (ptr_t)(p) < (ptr_t)GC_greatest_plausible_heap_addr) { \ + GC_mark_stack_top = GC_mark_and_push( \ +diff -urNb boehm-gc/include/private/gc_priv.h boehm-gc/include/private/gc_priv.h +--- boehm-gc/include/private/gc_priv.h Tue Mar 4 09:56:49 2003 ++++ boehm-gc/include/private/gc_priv.h Mon May 26 13:28:24 2003 +@@ -30,6 +30,12 @@ + # define BSD_TIME + #endif + ++#ifdef DGUX ++# include ++# include ++# include ++#endif /* DGUX */ ++ + #ifdef BSD_TIME + # include + # include +@@ -210,7 +216,6 @@ + # define ALIGN_DOUBLE + #endif + +- + /* ALIGN_DOUBLE requires MERGE_SIZES at present. */ + # if defined(ALIGN_DOUBLE) && !defined(MERGE_SIZES) + # define MERGE_SIZES +@@ -347,7 +352,8 @@ + # include + # define BCOPY_EXISTS + # endif +-# if defined(MACOSX) ++# if defined(DARWIN) ++# include + # define BCOPY_EXISTS + # endif + +@@ -360,68 +366,6 @@ + # define BZERO(x,n) bzero((char *)(x),(int)(n)) + # endif + +-/* HBLKSIZE aligned allocation. 0 is taken to mean failure */ +-/* space is assumed to be cleared. */ +-/* In the case os USE_MMAP, the argument must also be a */ +-/* physical page size. */ +-/* GET_MEM is currently not assumed to retrieve 0 filled space, */ +-/* though we should perhaps take advantage of the case in which */ +-/* does. */ +-struct hblk; /* See below. */ +-# ifdef PCR +- char * real_malloc(); +-# define GET_MEM(bytes) HBLKPTR(real_malloc((size_t)bytes + GC_page_size) \ +- + GC_page_size-1) +-# else +-# ifdef OS2 +- void * os2_alloc(size_t bytes); +-# define GET_MEM(bytes) HBLKPTR((ptr_t)os2_alloc((size_t)bytes \ +- + GC_page_size) \ +- + GC_page_size-1) +-# else +-# if defined(NEXT) || defined(MACOSX) || defined(DOS4GW) || \ +- (defined(AMIGA) && !defined(GC_AMIGA_FASTALLOC)) || \ +- (defined(SUNOS5) && !defined(USE_MMAP)) +-# define GET_MEM(bytes) HBLKPTR((size_t) \ +- calloc(1, (size_t)bytes + GC_page_size) \ +- + GC_page_size-1) +-# else +-# ifdef MSWIN32 +- extern ptr_t GC_win32_get_mem(); +-# define GET_MEM(bytes) (struct hblk *)GC_win32_get_mem(bytes) +-# else +-# ifdef MACOS +-# if defined(USE_TEMPORARY_MEMORY) +- extern Ptr GC_MacTemporaryNewPtr(size_t size, +- Boolean clearMemory); +-# define GET_MEM(bytes) HBLKPTR( \ +- GC_MacTemporaryNewPtr(bytes + GC_page_size, true) \ +- + GC_page_size-1) +-# else +-# define GET_MEM(bytes) HBLKPTR( \ +- NewPtrClear(bytes + GC_page_size) + GC_page_size-1) +-# endif +-# else +-# ifdef MSWINCE +- extern ptr_t GC_wince_get_mem(); +-# define GET_MEM(bytes) (struct hblk *)GC_wince_get_mem(bytes) +-# else +-# if defined(AMIGA) && defined(GC_AMIGA_FASTALLOC) +- extern void *GC_amiga_get_mem(size_t size); +- define GET_MEM(bytes) HBLKPTR((size_t) \ +- GC_amiga_get_mem((size_t)bytes + GC_page_size) \ +- + GC_page_size-1) +-# else +- extern ptr_t GC_unix_get_mem(); +-# define GET_MEM(bytes) (struct hblk *)GC_unix_get_mem(bytes) +-# endif +-# endif +-# endif +-# endif +-# endif +-# endif +-# endif +- + /* Delay any interrupts or signals that may abort this thread. Data */ + /* structures are in a consistent state outside this pair of calls. */ + /* ANSI C allows both to be empty (though the standard isn't very */ +@@ -486,7 +430,7 @@ + # ifdef SMALL_CONFIG + # define ABORT(msg) abort(); + # else +- GC_API void GC_abort(); ++ GC_API void GC_abort GC_PROTO((GC_CONST char * msg)); + # define ABORT(msg) GC_abort(msg); + # endif + # endif +@@ -646,9 +590,10 @@ + */ + + # ifdef LARGE_CONFIG +-# define LOG_PHT_ENTRIES 19 /* Collisions likely at 512K blocks, */ +- /* which is >= 2GB. Each table takes */ +- /* 64KB. */ ++# define LOG_PHT_ENTRIES 20 /* Collisions likely at 1M blocks, */ ++ /* which is >= 4GB. Each table takes */ ++ /* 128KB, some of which may never be */ ++ /* touched. */ + # else + # ifdef SMALL_CONFIG + # define LOG_PHT_ENTRIES 14 /* Collisions are likely if heap grows */ +@@ -656,7 +601,7 @@ + /* Each hash table occupies 2K bytes. */ + # else /* default "medium" configuration */ + # define LOG_PHT_ENTRIES 16 /* Collisions are likely if heap grows */ +- /* to more than 16K hblks >= 256MB. */ ++ /* to more than 64K hblks >= 256MB. */ + /* Each hash table occupies 8K bytes. */ + # endif + # endif +@@ -897,6 +842,10 @@ + word _mem_freed; + /* Number of explicitly deallocated words of memory */ + /* since last collection. */ ++ word _finalizer_mem_freed; ++ /* Words of memory explicitly deallocated while */ ++ /* finalizers were running. Used to approximate mem. */ ++ /* explicitly deallocated by finalizers. */ + ptr_t _scratch_end_ptr; + ptr_t _scratch_last_end_ptr; + /* Used by headers.c, and can easily appear to point to */ +@@ -957,7 +906,7 @@ + /* OFFSET_TOO_BIG if the value j would be too */ + /* large to fit in the entry. (Note that the */ + /* size of these entries matters, both for */ +- /* space consumption and for cache utilization. */ ++ /* space consumption and for cache utilization.) */ + # define OFFSET_TOO_BIG 0xfe + # define OBJ_INVALID 0xff + # define MAP_ENTRY(map, bytes) (map)[bytes] +@@ -1067,6 +1016,7 @@ + # define GC_words_finalized GC_arrays._words_finalized + # define GC_non_gc_bytes_at_gc GC_arrays._non_gc_bytes_at_gc + # define GC_mem_freed GC_arrays._mem_freed ++# define GC_finalizer_mem_freed GC_arrays._finalizer_mem_freed + # define GC_scratch_end_ptr GC_arrays._scratch_end_ptr + # define GC_scratch_last_end_ptr GC_arrays._scratch_last_end_ptr + # define GC_mark_procs GC_arrays._mark_procs +@@ -1201,17 +1151,19 @@ + /* header structure associated with */ + /* block. */ + +-extern GC_bool GC_is_initialized; /* GC_init() has been run. */ +- + extern GC_bool GC_objects_are_marked; /* There are marked objects in */ + /* the heap. */ + + #ifndef SMALL_CONFIG + extern GC_bool GC_incremental; + /* Using incremental/generational collection. */ ++# define TRUE_INCREMENTAL \ ++ (GC_incremental && GC_time_limit != GC_TIME_UNLIMITED) ++ /* True incremental, not just generational, mode */ + #else + # define GC_incremental FALSE + /* Hopefully allow optimizer to remove some code. */ ++# define TRUE_INCREMENTAL FALSE + #endif + + extern GC_bool GC_dirty_maintained; +@@ -1229,6 +1181,10 @@ + extern long GC_large_alloc_warn_suppressed; + /* Number of warnings suppressed so far. */ + ++#ifdef THREADS ++ extern GC_bool GC_world_stopped; ++#endif ++ + /* Operations */ + # ifndef abs + # define abs(x) ((x) < 0? (-(x)) : (x)) +@@ -1452,6 +1408,7 @@ + /* Set all mark bits associated with */ + /* a free list. */ + void GC_add_roots_inner GC_PROTO((char * b, char * e, GC_bool tmp)); ++void GC_remove_roots_inner GC_PROTO((char * b, char * e)); + GC_bool GC_is_static_root GC_PROTO((ptr_t p)); + /* Is the address p in one of the registered static */ + /* root sections? */ +@@ -1624,6 +1581,8 @@ + /* until the blocks are available or */ + /* until it fails by returning FALSE. */ + ++extern GC_bool GC_is_initialized; /* GC_init() has been run. */ ++ + #if defined(MSWIN32) || defined(MSWINCE) + void GC_deinit GC_PROTO((void)); + /* Free any resources allocated by */ +@@ -1666,6 +1625,8 @@ + /* free list nonempty, and return its */ + /* head. */ + ++void GC_free_inner(GC_PTR p); ++ + void GC_init_headers GC_PROTO((void)); + struct hblkhdr * GC_install_header GC_PROTO((struct hblk *h)); + /* Install a header for block h. */ +@@ -1695,6 +1656,12 @@ + /* finalizers to be run, and we haven't called */ + /* this procedure yet this GC cycle. */ + ++GC_API GC_PTR GC_make_closure GC_PROTO((GC_finalization_proc fn, GC_PTR data)); ++GC_API void GC_debug_invoke_finalizer GC_PROTO((GC_PTR obj, GC_PTR data)); ++ /* Auxiliary fns to make finalization work */ ++ /* correctly with displaced pointers introduced */ ++ /* by the debugging allocators. */ ++ + void GC_add_to_heap GC_PROTO((struct hblk *p, word bytes)); + /* Add a HBLKSIZE aligned chunk to the heap. */ + +@@ -1704,16 +1671,36 @@ + /* description of the object to stderr. */ + extern void (*GC_check_heap) GC_PROTO((void)); + /* Check that all objects in the heap with */ +- /* debugging info are intact. Print */ +- /* descriptions of any that are not. */ ++ /* debugging info are intact. */ ++ /* Add any that are not to GC_smashed list. */ ++extern void (*GC_print_all_smashed) GC_PROTO((void)); ++ /* Print GC_smashed if it's not empty. */ ++ /* Clear GC_smashed list. */ ++extern void GC_print_all_errors GC_PROTO((void)); ++ /* Print smashed and leaked objects, if any. */ ++ /* Clear the lists of such objects. */ + extern void (*GC_print_heap_obj) GC_PROTO((ptr_t p)); + /* If possible print s followed by a more */ + /* detailed description of the object */ + /* referred to by p. */ ++#if defined(LINUX) && defined(__ELF__) && !defined(SMALL_CONFIG) ++ void GC_print_address_map GC_PROTO((void)); ++ /* Print an address map of the process. */ ++#endif + ++extern GC_bool GC_have_errors; /* We saw a smashed or leaked object. */ ++ /* Call error printing routine */ ++ /* occasionally. */ + extern GC_bool GC_print_stats; /* Produce at least some logging output */ + /* Set from environment variable. */ + ++#ifndef NO_DEBUGGING ++ extern GC_bool GC_dump_regularly; /* Generate regular debugging dumps. */ ++# define COND_DUMP if (GC_dump_regularly) GC_dump(); ++#else ++# define COND_DUMP ++#endif ++ + /* Macros used for collector internal allocation. */ + /* These assume the collector lock is held. */ + #ifdef DBG_HDRS_ALL +@@ -1785,6 +1772,7 @@ + void GC_print_hblkfreelist GC_PROTO((void)); + void GC_print_heap_sects GC_PROTO((void)); + void GC_print_static_roots GC_PROTO((void)); ++void GC_print_finalization_stats GC_PROTO((void)); + void GC_dump GC_PROTO((void)); + + #ifdef KEEP_BACK_PTRS +@@ -1866,6 +1854,10 @@ + # define GC_ASSERT(expr) + # endif + ++/* Check a compile time assertion at compile time. The error */ ++/* message for failure is a bit baroque, but ... */ ++# define GC_STATIC_ASSERT(expr) sizeof(char[(expr)? 1 : -1]) ++ + # if defined(PARALLEL_MARK) || defined(THREAD_LOCAL_ALLOC) + /* We need additional synchronization facilities from the thread */ + /* support. We believe these are less performance critical */ +@@ -1911,7 +1903,7 @@ + /* in Linux glibc, but it's not exported.) Thus we continue to use */ + /* the same hard-coded signals we've always used. */ + # if !defined(SIG_SUSPEND) +-# if defined(GC_LINUX_THREADS) ++# if defined(GC_LINUX_THREADS) || defined(GC_DGUX386_THREADS) + # if defined(SPARC) && !defined(SIGPWR) + /* SPARC/Linux doesn't properly define SIGPWR in . + * It is aliased to SIGLOST in asm/signal.h, though. */ +diff -urNb boehm-gc/include/private/gcconfig.h boehm-gc/include/private/gcconfig.h +--- boehm-gc/include/private/gcconfig.h Wed Apr 9 17:08:01 2003 ++++ boehm-gc/include/private/gcconfig.h Mon May 26 13:28:24 2003 +@@ -14,10 +14,24 @@ + * modified is included with the above copyright notice. + */ + ++/* ++ * This header is private to the gc. It is almost always included from ++ * gc_priv.h. However it is possible to include it by itself if just the ++ * configuration macros are needed. In that ++ * case, a few declarations relying on types declared in gc_priv.h will be ++ * omitted. ++ */ ++ + #ifndef GCCONFIG_H + + # define GCCONFIG_H + ++# ifndef GC_PRIVATE_H ++ /* Fake ptr_t declaration, just to avoid compilation errors. */ ++ /* This avoids many instances if "ifndef GC_PRIVATE_H" below. */ ++ typedef struct GC_undefined_struct * ptr_t; ++# endif ++ + /* Machine dependent parameters. Some tuning parameters can be found */ + /* near the top of gc_private.h. */ + +@@ -44,7 +58,7 @@ + # endif + + /* Determine the machine type: */ +-# if defined(__arm__) || defined(__thumb__) ++# if defined(__XSCALE__) + # define ARM32 + # if !defined(LINUX) + # define NOSYS +@@ -95,8 +109,8 @@ + # if defined(nec_ews) || defined(_nec_ews) + # define EWS4800 + # endif +-# if !defined(LINUX) && !defined(EWS4800) && !defined(NETBSD) +-# if defined(ultrix) || defined(__ultrix) ++# if !defined(LINUX) && !defined(EWS4800) ++# if defined(ultrix) || defined(__ultrix) || defined(__NetBSD__) + # define ULTRIX + # else + # if defined(_SYSTYPE_SVR4) || defined(SYSTYPE_SVR4) \ +@@ -107,6 +121,16 @@ + # endif + # endif + # endif /* !LINUX */ ++# if defined(__NetBSD__) && defined(__MIPSEL__) ++# undef ULTRIX ++# endif ++# define mach_type_known ++# endif ++# if defined(DGUX) && (defined(i386) || defined(__i386__)) ++# define I386 ++# ifndef _USING_DGUX ++# define _USING_DGUX ++# endif + # define mach_type_known + # endif + # if defined(sequent) && (defined(i386) || defined(__i386__)) +@@ -198,6 +222,10 @@ + # define IA64 + # define mach_type_known + # endif ++# if defined(LINUX) && defined(__arm__) ++# define ARM32 ++# define mach_type_known ++# endif + # if defined(LINUX) && (defined(powerpc) || defined(__powerpc__)) + # define POWERPC + # define mach_type_known +@@ -237,19 +265,19 @@ + # define MACOS + # define mach_type_known + # endif +-# if defined(__MWERKS__) && defined(__powerc) ++# if defined(__MWERKS__) && defined(__powerc) && !defined(__MACH__) + # define POWERPC + # define MACOS + # define mach_type_known + # endif + # if defined(macosx) || \ + defined(__APPLE__) && defined(__MACH__) && defined(__ppc__) +-# define MACOSX ++# define DARWIN + # define POWERPC + # define mach_type_known + # endif + # if defined(__APPLE__) && defined(__MACH__) && defined(__i386__) +-# define MACOSX ++# define DARWIN + # define I386 + --> Not really supported, but at least we recognize it. + # endif +@@ -291,7 +319,7 @@ + # define CX_UX + # define mach_type_known + # endif +-# if defined(DGUX) ++# if defined(DGUX) && defined(m88k) + # define M88K + /* DGUX defined */ + # define mach_type_known +@@ -425,8 +453,6 @@ + /* IA64 ==> Intel IPF */ + /* (e.g. Itanium) */ + /* (LINUX and HPUX) */ +- /* IA64_32 ==> IA64 w/32 bit ABI */ +- /* (HPUX) */ + /* SH ==> Hitachi SuperH */ + /* (LINUX & MSWINCE) */ + /* X86_64 ==> AMD x86-64 */ +@@ -450,15 +476,17 @@ + * defining it to be 1 will always work, but perform poorly. + * + * DATASTART is the beginning of the data segment. +- * On UNIX systems, the collector will scan the area between DATASTART ++ * On some platforms SEARCH_FOR_DATA_START is defined. ++ * SEARCH_FOR_DATASTART will cause GC_data_start to ++ * be set to an address determined by accessing data backwards from _end ++ * until an unmapped page is found. DATASTART will be defined to be ++ * GC_data_start. ++ * On UNIX-like systems, the collector will scan the area between DATASTART + * and DATAEND for root pointers. + * + * DATAEND, if not `end' where `end' is defined as ``extern int end[];''. + * RTH suggests gaining access to linker script synth'd values with + * this idiom instead of `&end' where `end' is defined as ``extern int end;'' . +- * Otherwise, ``GCC will assume these are in .sdata/.sbss'' and it will, e.g., +- * cause failures on alpha*-*-* with ``-msmall-data or -fpic'' or mips-*-* +- * without any special options. + * + * ALIGN_DOUBLE of GC_malloc should return blocks aligned to twice + * the pointer size. +@@ -470,8 +498,13 @@ + * 1) define STACK_GROWS_UP if the stack grows toward higher addresses, and + * 2) define exactly one of + * STACKBOTTOM (should be defined to be an expression) ++ * LINUX_STACKBOTTOM + * HEURISTIC1 + * HEURISTIC2 ++ * If STACKBOTTOM is defined, then it's value will be used directly as the ++ * stack base. If LINUX_STACKBOTTOM is defined, then it will be determined ++ * with a method appropriate for most Linux systems. Currently we look ++ * first for __libc_stack_end, and if that fails read it from /proc. + * If either of the last two macros are defined, then STACKBOTTOM is computed + * during collector startup using one of the following two heuristics: + * HEURISTIC1: Take an address inside GC_init's frame, and round it up to +@@ -536,6 +569,9 @@ + * An architecture may also define CLEAR_DOUBLE(x) to be a fast way to + * clear the two words at GC_malloc-aligned address x. By default, + * word stores of 0 are used instead. ++ * ++ * HEAP_START may be defined as the initial address hint for mmap-based ++ * allocation. + */ + + /* If we are using a recent version of gcc, we can use __builtin_unwind_init() +@@ -571,7 +607,7 @@ + # define DYNAMIC_LOADING + # include + # if defined(__GLIBC__)&& __GLIBC__>=2 +-# define LINUX_DATA_START ++# define SEARCH_FOR_DATA_START + # else /* !GLIBC2 */ + extern char **__environ; + # define DATASTART ((ptr_t)(&__environ)) +@@ -669,23 +705,42 @@ + # define ALIGNMENT 4 /* Guess. Can someone verify? */ + /* This was 2, but that didn't sound right. */ + # define OS_TYPE "LINUX" +-# define DYNAMIC_LOADING ++ /* HEURISTIC1 has been reliably reported to fail for a 32-bit */ ++ /* executable on a 64 bit kernel. */ + # define LINUX_STACKBOTTOM +- /* Stack usually starts at 0x80000000 */ +-# define LINUX_DATA_START ++# define DYNAMIC_LOADING ++# define SEARCH_FOR_DATA_START + extern int _end[]; + # define DATAEND (_end) + # endif +-# ifdef MACOSX ++# ifdef DARWIN + /* There are reasons to suspect this may not be reliable. */ + # define ALIGNMENT 4 +-# define OS_TYPE "MACOSX" ++# define OS_TYPE "DARWIN" ++# define DYNAMIC_LOADING ++ /* XXX: see get_end(3), get_etext() and get_end() should not be used. ++ These aren't used when dyld support is enabled (it is by default) */ + # define DATASTART ((ptr_t) get_etext()) ++# define DATAEND ((ptr_t) get_end()) + # define STACKBOTTOM ((ptr_t) 0xc0000000) +-# define DATAEND /* not needed */ +-# undef MPROTECT_VDB ++# define USE_MMAP ++# define USE_MMAP_ANON ++# define USE_ASM_PUSH_REGS ++ /* This is potentially buggy. It needs more testing. See the comments in ++ os_dep.c */ ++# define MPROTECT_VDB + # include + # define GETPAGESIZE() getpagesize() ++# if defined(USE_PPC_PREFETCH) && defined(__GNUC__) ++ /* The performance impact of prefetches is untested */ ++# define PREFETCH(x) \ ++ __asm__ __volatile__ ("dcbt 0,%0" : : "r" ((const void *) (x))) ++# define PREFETCH_FOR_WRITE(x) \ ++ __asm__ __volatile__ ("dcbtst 0,%0" : : "r" ((const void *) (x))) ++# endif ++ /* There seems to be some issues with trylock hanging on darwin. This ++ should be looked into some more */ ++# define NO_PTHREAD_TRYLOCK + # endif + # ifdef NETBSD + # define ALIGNMENT 4 +@@ -746,8 +801,8 @@ + # define OS_TYPE "SUNOS5" + extern int _etext[]; + extern int _end[]; +- extern char * GC_SysVGetDataStart(); +-# define DATASTART (ptr_t)GC_SysVGetDataStart(0x10000, _etext) ++ extern ptr_t GC_SysVGetDataStart(); ++# define DATASTART GC_SysVGetDataStart(0x10000, _etext) + # define DATAEND (_end) + # if !defined(USE_MMAP) && defined(REDIRECT_MALLOC) + # define USE_MMAP +@@ -801,9 +856,9 @@ + # endif + # ifdef DRSNX + # define OS_TYPE "DRSNX" +- extern char * GC_SysVGetDataStart(); ++ extern ptr_t GC_SysVGetDataStart(); + extern int etext[]; +-# define DATASTART (ptr_t)GC_SysVGetDataStart(0x10000, etext) ++# define DATASTART GC_SysVGetDataStart(0x10000, etext) + # define MPROTECT_VDB + # define STACKBOTTOM ((ptr_t) 0xdfff0000) + # define DYNAMIC_LOADING +@@ -819,13 +874,14 @@ + extern int _etext[]; + # define DATAEND (_end) + # define SVR4 ++ extern ptr_t GC_SysVGetDataStart(); + # ifdef __arch64__ ++# define DATASTART GC_SysVGetDataStart(0x100000, _etext) + /* libc_stack_end is not set reliably for sparc64 */ +-# define STACKBOTTOM ((ptr_t) 0x80000000000) +-# define DATASTART (ptr_t)GC_SysVGetDataStart(0x100000, _etext) ++# define STACKBOTTOM ((ptr_t) 0x80000000000ULL) + # else ++# define DATASTART GC_SysVGetDataStart(0x10000, _etext) + # define LINUX_STACKBOTTOM +-# define DATASTART (ptr_t)GC_SysVGetDataStart(0x10000, _etext) + # endif + # endif + # ifdef OPENBSD +@@ -876,7 +932,7 @@ + # ifdef SUNOS5 + # define OS_TYPE "SUNOS5" + extern int _etext[], _end[]; +- extern char * GC_SysVGetDataStart(); ++ extern ptr_t GC_SysVGetDataStart(); + # define DATASTART GC_SysVGetDataStart(0x1000, _etext) + # define DATAEND (_end) + /* # define STACKBOTTOM ((ptr_t)(_start)) worked through 2.7, */ +@@ -921,6 +977,28 @@ + # define DYNAMIC_LOADING + # define ELF_CLASS ELFCLASS32 + # endif ++# ifdef DGUX ++# define OS_TYPE "DGUX" ++ extern int _etext, _end; ++ extern ptr_t GC_SysVGetDataStart(); ++# define DATASTART GC_SysVGetDataStart(0x1000, &_etext) ++# define DATAEND (&_end) ++# define STACK_GROWS_DOWN ++# define HEURISTIC2 ++# include ++# define GETPAGESIZE() sysconf(_SC_PAGESIZE) ++# define DYNAMIC_LOADING ++# ifndef USE_MMAP ++# define USE_MMAP ++# endif /* USE_MMAP */ ++# define MAP_FAILED (void *) -1 ++# ifdef USE_MMAP ++# define HEAP_START (ptr_t)0x40000000 ++# else /* USE_MMAP */ ++# define HEAP_START DATAEND ++# endif /* USE_MMAP */ ++# endif /* DGUX */ ++ + # ifdef LINUX + # ifndef __GNUC__ + /* The Intel compiler doesn't like inline assembly */ +@@ -944,6 +1022,9 @@ + /* possibly because Linux threads is itself a malloc client */ + /* and can't deal with the signals. */ + # endif ++# define HEAP_START 0x1000 ++ /* This encourages mmap to give us low addresses, */ ++ /* thus allowing the heap to grow to ~3GB */ + # ifdef __ELF__ + # define DYNAMIC_LOADING + # ifdef UNDEFINED /* includes ro data */ +@@ -952,7 +1033,7 @@ + # endif + # include + # if defined(__GLIBC__) && __GLIBC__ >= 2 +-# define LINUX_DATA_START ++# define SEARCH_FOR_DATA_START + # else + extern char **__environ; + # define DATASTART ((ptr_t)(&__environ)) +@@ -1061,16 +1142,9 @@ + # ifdef __ELF__ + # define DYNAMIC_LOADING + # endif +-/* Handle unmapped hole i386*-*-freebsd[45]* may put between etext and edata. */ + extern char etext[]; +- extern char edata[]; +- extern char end[]; +-# define NEED_FIND_LIMIT +-# define DATASTART ((ptr_t)(etext)) +-# define MIN(x,y) ((x) < (y) ? (x) : (y)) +-# define DATAEND (MIN (GC_find_limit (DATASTART, TRUE), DATASTART2)) +-# define DATASTART2 ((ptr_t)(edata)) +-# define DATAEND2 ((ptr_t)(end)) ++ extern char * GC_FreeBSDGetDataStart(); ++# define DATASTART GC_FreeBSDGetDataStart(0x1000, &etext) + # endif + # ifdef NETBSD + # define OS_TYPE "NETBSD" +@@ -1149,7 +1223,11 @@ + # define DATASTART ((ptr_t)(__data_start)) + # define ALIGNMENT 4 + # define USE_GENERIC_PUSH_REGS ++# if __GLIBC__ == 2 && __GLIBC_MINOR__ >= 2 || __GLIBC__ > 2 + # define LINUX_STACKBOTTOM ++# else ++# define STACKBOTTOM 0x80000000 ++# endif + # endif /* Linux */ + # ifdef EWS4800 + # define HEURISTIC2 +@@ -1222,15 +1300,21 @@ + # define DATAEND /* not needed */ + # endif + # if defined(NETBSD) +-# define OS_TYPE "NETBSD" ++ /* This also checked for __MIPSEL__ . Why? NETBSD recognition */ ++ /* should be handled at the top of the file. */ + # define ALIGNMENT 4 ++# define OS_TYPE "NETBSD" + # define HEURISTIC2 + # define USE_GENERIC_PUSH_REGS +- extern int _fdata[]; +-# define DATASTART ((ptr_t)(_fdata)) +- extern int _end[]; +-# define DATAEND ((ptr_t)(_end)) ++# ifdef __ELF__ ++ extern int etext[]; ++# define DATASTART GC_data_start ++# define NEED_FIND_LIMIT + # define DYNAMIC_LOADING ++# else ++# define DATASTART ((ptr_t) 0x10000000) ++# define STACKBOTTOM ((ptr_t) 0x7ffff000) ++# endif /* _ELF_ */ + # endif + # endif + +@@ -1239,15 +1323,16 @@ + # ifdef __64BIT__ + # define ALIGNMENT 8 + # define CPP_WORDSZ 64 ++# define STACKBOTTOM 0x1000000000000000 + # else + # define ALIGNMENT 4 + # define CPP_WORDSZ 32 ++# define STACKBOTTOM ((ptr_t)((ulong)&errno)) + # endif + extern int _data[], _end[]; + # define DATASTART ((ptr_t)((ulong)_data)) + # define DATAEND ((ptr_t)((ulong)_end)) + extern int errno; +-# define STACKBOTTOM ((ptr_t)((ulong)&errno)) + # define USE_GENERIC_PUSH_REGS + # define DYNAMIC_LOADING + /* For really old versions of AIX, this may have to be removed. */ +@@ -1311,15 +1396,23 @@ + # define OS_TYPE "LINUX" + # define LINUX_STACKBOTTOM + # define DYNAMIC_LOADING +-# define LINUX_DATA_START ++# define SEARCH_FOR_DATA_START + extern int _end[]; +-# define DATAEND (_end) ++# define DATAEND (&_end) + # endif /* LINUX */ + # endif /* HP_PA */ + + # ifdef ALPHA + # define MACH_TYPE "ALPHA" + # define ALIGNMENT 8 ++# define CPP_WORDSZ 64 ++# ifndef LINUX ++# define USE_GENERIC_PUSH_REGS ++ /* Gcc and probably the DEC/Compaq compiler spill pointers to preserved */ ++ /* fp registers in some cases when the target is a 21264. The assembly */ ++ /* code doesn't handle that yet, and version dependencies make that a */ ++ /* bit tricky. Do the easy thing for now. */ ++# endif + # ifdef NETBSD + # define OS_TYPE "NETBSD" + # define HEURISTIC2 +@@ -1327,13 +1420,11 @@ + # define ELFCLASS32 32 + # define ELFCLASS64 64 + # define ELF_CLASS ELFCLASS64 +-# define CPP_WORDSZ 64 + # define DYNAMIC_LOADING + # endif + # ifdef OPENBSD + # define OS_TYPE "OPENBSD" + # define HEURISTIC2 +-# define CPP_WORDSZ 64 + # ifdef __ELF__ /* since OpenBSD/Alpha 2.9 */ + # define DATASTART GC_data_start + # define ELFCLASS32 32 +@@ -1357,17 +1448,16 @@ + extern char edata[]; + extern char end[]; + # define NEED_FIND_LIMIT +-# define DATASTART ((ptr_t)(etext)) ++# define DATASTART ((ptr_t)(&etext)) + # define DATAEND (GC_find_limit (DATASTART, TRUE)) +-# define DATASTART2 ((ptr_t)(edata)) +-# define DATAEND2 ((ptr_t)(end)) +-# define CPP_WORDSZ 64 ++# define DATASTART2 ((ptr_t)(&edata)) ++# define DATAEND2 ((ptr_t)(&end)) + # endif + # ifdef OSF1 + # define OS_TYPE "OSF1" + # define DATASTART ((ptr_t) 0x140000000) + extern int _end[]; +-# define DATAEND ((ptr_t) _end) ++# define DATAEND ((ptr_t) &_end) + extern char ** environ; + /* round up from the value of environ to the nearest page boundary */ + /* Probably breaks if putenv is called before collector */ +@@ -1380,17 +1470,17 @@ + /* This is currently unused, since we disabled HEURISTIC2 */ + extern int __start[]; + # define HEURISTIC2_LIMIT ((ptr_t)((word)(__start) & ~(getpagesize()-1))) +-# define CPP_WORDSZ 64 ++# ifndef GC_OSF1_THREADS ++ /* Unresolved signal issues with threads. */ + # define MPROTECT_VDB ++# endif + # define DYNAMIC_LOADING + # endif + # ifdef LINUX + # define OS_TYPE "LINUX" +-# define CPP_WORDSZ 64 + # define STACKBOTTOM ((ptr_t) 0x120000000) + # ifdef __ELF__ + # define SEARCH_FOR_DATA_START +-# define DATASTART GC_data_start + # define DYNAMIC_LOADING + # else + # define DATASTART ((ptr_t) 0x140000000) +@@ -1468,7 +1558,6 @@ + extern char * GC_register_stackbottom; + # define BACKING_STORE_BASE ((ptr_t)GC_register_stackbottom) + # define SEARCH_FOR_DATA_START +-# define DATASTART GC_data_start + # ifdef __GNUC__ + # define DYNAMIC_LOADING + # else +@@ -1502,13 +1591,15 @@ + # endif + # ifdef DGUX + # define OS_TYPE "DGUX" +- extern char * GC_SysVGetDataStart(); +-# define DATASTART (ptr_t)GC_SysVGetDataStart(0x10000, etext) ++ extern ptr_t GC_SysVGetDataStart(); ++# define DATASTART GC_SysVGetDataStart(0x10000, etext) + # endif + # define STACKBOTTOM ((char*)0xf0000000) /* determined empirically */ + # endif + + # ifdef S370 ++ /* If this still works, and if anyone cares, this should probably */ ++ /* be moved to the S390 category. */ + # define MACH_TYPE "S370" + # define ALIGNMENT 4 /* Required by hardware */ + # define USE_GENERIC_PUSH_REGS +@@ -1517,8 +1608,8 @@ + extern int etext[]; + extern int _etext[]; + extern int _end[]; +- extern char * GC_SysVGetDataStart(); +-# define DATASTART (ptr_t)GC_SysVGetDataStart(0x10000, _etext) ++ extern ptr_t GC_SysVGetDataStart(); ++# define DATASTART GC_SysVGetDataStart(0x10000, _etext) + # define DATAEND (_end) + # define HEURISTIC2 + # endif +@@ -1576,7 +1667,7 @@ + # define DYNAMIC_LOADING + # include + # if defined(__GLIBC__) && __GLIBC__ >= 2 +-# define LINUX_DATA_START ++# define SEARCH_FOR_DATA_START + # else + extern char **__environ; + # define DATASTART ((ptr_t)(&__environ)) +@@ -1623,7 +1714,7 @@ + # define STACKBOTTOM ((ptr_t) 0x7c000000) + # define USE_GENERIC_PUSH_REGS + # define DYNAMIC_LOADING +-# define LINUX_DATA_START ++# define SEARCH_FOR_DATA_START + extern int _end[]; + # define DATAEND (_end) + # endif +@@ -1640,7 +1731,9 @@ + # define MACH_TYPE "X86_64" + # define ALIGNMENT 8 + # define CPP_WORDSZ 64 ++# ifndef HBLKSIZE + # define HBLKSIZE 4096 ++# endif + # define CACHE_LINE_SIZE 64 + # define USE_GENERIC_PUSH_REGS + # ifdef LINUX +@@ -1660,7 +1753,7 @@ + # define DATASTART ((ptr_t)((((word) (_etext)) + 0xfff) & ~0xfff)) + # endif + # include +-# define LINUX_DATA_START ++# define SEARCH_FOR_DATA_START + extern int _end[]; + # define DATAEND (_end) + # else +@@ -1674,19 +1767,6 @@ + # endif + # endif + +-#ifdef LINUX_DATA_START +- /* Some Linux distributions arrange to define __data_start. Some */ +- /* define data_start as a weak symbol. The latter is technically */ +- /* broken, since the user program may define data_start, in which */ +- /* case we lose. Nonetheless, we try both, prefering __data_start. */ +- /* We assume gcc. */ +-# pragma weak __data_start +- extern int __data_start[]; +-# pragma weak data_start +- extern int data_start[]; +-# define DATASTART ((ptr_t)(__data_start != 0? __data_start : data_start)) +-#endif +- + #if defined(LINUX) && defined(REDIRECT_MALLOC) + /* Rld appears to allocate some memory with its own allocator, and */ + /* some through malloc, which might be redirected. To make this */ +@@ -1742,8 +1822,8 @@ + # endif + + # if defined(SVR4) || defined(LINUX) || defined(IRIX) || defined(HPUX) \ +- || defined(OPENBSD) || defined(NETBSD) || defined(FREEBSD) \ +- || defined(BSD) || defined(_AIX) || defined(MACOSX) || defined(OSF1) ++ || defined(OPENBSD) || defined(NETBSD) || defined(FREEBSD) || defined(DGUX) \ ++ || defined(BSD) || defined(AIX) || defined(DARWIN) || defined(OSF1) + # define UNIX_LIKE /* Basic Unix-like system calls work. */ + # endif + +@@ -1762,13 +1842,13 @@ + # endif + + # ifdef SRC_M3 +-/* Postponed for now. */ ++ /* Postponed for now. */ + # undef PROC_VDB + # undef MPROTECT_VDB + # endif + + # ifdef SMALL_CONFIG +-/* Presumably not worth the space it takes. */ ++ /* Presumably not worth the space it takes. */ + # undef PROC_VDB + # undef MPROTECT_VDB + # endif +@@ -1808,8 +1888,9 @@ + /* platforms as well, though it should be avoided in win32. */ + # endif /* LINUX */ + +-# if defined(SEARCH_FOR_DATA_START) && defined(GC_PRIVATE_H) ++# if defined(SEARCH_FOR_DATA_START) + extern ptr_t GC_data_start; ++# define DATASTART GC_data_start + # endif + + # ifndef CLEAR_DOUBLE +@@ -1818,28 +1899,25 @@ + ((word*)x)[1] = 0; + # endif /* CLEAR_DOUBLE */ + +-/* Internally we use GC_SOLARIS_THREADS to test for either old or pthreads. */ ++ /* Internally we use GC_SOLARIS_THREADS to test for either old or pthreads. */ + # if defined(GC_SOLARIS_PTHREADS) && !defined(GC_SOLARIS_THREADS) + # define GC_SOLARIS_THREADS + # endif + + # if defined(GC_IRIX_THREADS) && !defined(IRIX5) +---> inconsistent configuration ++ --> inconsistent configuration + # endif + # if defined(GC_LINUX_THREADS) && !defined(LINUX) +---> inconsistent configuration ++ --> inconsistent configuration + # endif + # if defined(GC_SOLARIS_THREADS) && !defined(SUNOS5) +---> inconsistent configuration ++ --> inconsistent configuration + # endif + # if defined(GC_HPUX_THREADS) && !defined(HPUX) +---> inconsistent configuration ++ --> inconsistent configuration + # endif +-# if defined(GC_WIN32_THREADS) && !defined(MSWIN32) +- /* Ideally CYGWIN32 should work, in addition to MSWIN32. I suspect */ +- /* the necessary code is mostly there, but nobody has actually made */ +- /* sure the right combination of pieces is compiled in, etc. */ +---> inconsistent configuration ++# if defined(GC_WIN32_THREADS) && !defined(MSWIN32) && !defined(CYGWIN32) ++ --> inconsistent configuration + # endif + + # if defined(PCR) || defined(SRC_M3) || \ +@@ -1848,8 +1926,8 @@ + # define THREADS + # endif + +-# if defined(HP_PA) || defined(M88K) || defined(POWERPC) && !defined(MACOSX) \ +- || defined(LINT) || defined(MSWINCE) \ ++# if defined(HP_PA) || defined(M88K) || defined(POWERPC) && !defined(DARWIN) \ ++ || defined(LINT) || defined(MSWINCE) || defined(ARM32) \ + || (defined(I386) && defined(__LCC__)) + /* Use setjmp based hack to mark from callee-save registers. */ + /* The define should move to the individual platform */ +@@ -1862,36 +1940,26 @@ + /* include assembly code to do it well. */ + # endif + +-/* Can we save call chain in objects for debugging? */ +-/* SET NFRAMES (# of saved frames) and NARGS (#of args for each frame) */ +-/* to reasonable values for the platform. */ +-/* Set SAVE_CALL_CHAIN if we can. SAVE_CALL_COUNT can be specified at */ +-/* build time, though we feel free to adjust it slightly. */ +-/* Define NEED_CALLINFO if we either save the call stack or */ +-/* GC_ADD_CALLER is defined. */ +-#ifdef LINUX +-# include +-# if __GLIBC__ == 2 && __GLIBC_MINOR__ >= 1 || __GLIBC__ > 2 +-# define HAVE_BUILTIN_BACKTRACE +-# endif +-#endif ++ /* Can we save call chain in objects for debugging? */ ++ /* SET NFRAMES (# of saved frames) and NARGS (#of args for each */ ++ /* frame) to reasonable values for the platform. */ ++ /* Set SAVE_CALL_CHAIN if we can. SAVE_CALL_COUNT can be specified */ ++ /* at build time, though we feel free to adjust it slightly. */ ++ /* Define NEED_CALLINFO if we either save the call stack or */ ++ /* GC_ADD_CALLER is defined. */ ++ /* GC_CAN_SAVE_CALL_STACKS is set in gc.h. */ + + #if defined(SPARC) +-# define CAN_SAVE_CALL_STACKS + # define CAN_SAVE_CALL_ARGS + #endif + #if (defined(I386) || defined(X86_64)) && defined(LINUX) + /* SAVE_CALL_CHAIN is supported if the code is compiled to save */ + /* frame pointers by default, i.e. no -fomit-frame-pointer flag. */ +-# define CAN_SAVE_CALL_STACKS + # define CAN_SAVE_CALL_ARGS + #endif +-#if defined(HAVE_BUILTIN_BACKTRACE) && !defined(CAN_SAVE_CALL_STACKS) +-# define CAN_SAVE_CALL_STACKS +-#endif + + # if defined(SAVE_CALL_COUNT) && !defined(GC_ADD_CALLER) \ +- && defined(CAN_SAVE_CALL_STACKS) ++ && defined(GC_CAN_SAVE_CALL_STACKS) + # define SAVE_CALL_CHAIN + # endif + # ifdef SAVE_CALL_CHAIN +@@ -1919,5 +1987,97 @@ + # if defined(MAKE_BACK_GRAPH) && !defined(DBG_HDRS_ALL) + # define DBG_HDRS_ALL + # endif ++ ++# if defined(POINTER_MASK) && !defined(POINTER_SHIFT) ++# define POINTER_SHIFT 0 ++# endif ++ ++# if defined(POINTER_SHIFT) && !defined(POINTER_MASK) ++# define POINTER_MASK ((GC_word)(-1)) ++# endif ++ ++# if !defined(FIXUP_POINTER) && defined(POINTER_MASK) ++# define FIXUP_POINTER(p) (p) = ((p) & (POINTER_MASK) << POINTER_SHIFT) ++# endif ++ ++# if defined(FIXUP_POINTER) ++# define NEED_FIXUP_POINTER 1 ++# else ++# define NEED_FIXUP_POINTER 0 ++# define FIXUP_POINTER(p) ++# endif ++ ++#ifdef GC_PRIVATE_H ++ /* This relies on some type definitions from gc_priv.h, from */ ++ /* where it's normally included. */ ++ /* */ ++ /* How to get heap memory from the OS: */ ++ /* Note that sbrk()-like allocation is preferred, since it */ ++ /* usually makes it possible to merge consecutively allocated */ ++ /* chunks. It also avoids unintented recursion with */ ++ /* -DREDIRECT_MALLOC. */ ++ /* GET_MEM() returns a HLKSIZE aligned chunk. */ ++ /* 0 is taken to mean failure. */ ++ /* In the case os USE_MMAP, the argument must also be a */ ++ /* physical page size. */ ++ /* GET_MEM is currently not assumed to retrieve 0 filled space, */ ++ /* though we should perhaps take advantage of the case in which */ ++ /* does. */ ++ struct hblk; /* See gc_priv.h. */ ++# ifdef PCR ++ char * real_malloc(); ++# define GET_MEM(bytes) HBLKPTR(real_malloc((size_t)bytes + GC_page_size) \ ++ + GC_page_size-1) ++# else ++# ifdef OS2 ++ void * os2_alloc(size_t bytes); ++# define GET_MEM(bytes) HBLKPTR((ptr_t)os2_alloc((size_t)bytes \ ++ + GC_page_size) \ ++ + GC_page_size-1) ++# else ++# if defined(NEXT) || defined(DOS4GW) || \ ++ (defined(AMIGA) && !defined(GC_AMIGA_FASTALLOC)) || \ ++ (defined(SUNOS5) && !defined(USE_MMAP)) ++# define GET_MEM(bytes) HBLKPTR((size_t) \ ++ calloc(1, (size_t)bytes + GC_page_size) \ ++ + GC_page_size-1) ++# else ++# ifdef MSWIN32 ++ extern ptr_t GC_win32_get_mem(); ++# define GET_MEM(bytes) (struct hblk *)GC_win32_get_mem(bytes) ++# else ++# ifdef MACOS ++# if defined(USE_TEMPORARY_MEMORY) ++ extern Ptr GC_MacTemporaryNewPtr(size_t size, ++ Boolean clearMemory); ++# define GET_MEM(bytes) HBLKPTR( \ ++ GC_MacTemporaryNewPtr(bytes + GC_page_size, true) \ ++ + GC_page_size-1) ++# else ++# define GET_MEM(bytes) HBLKPTR( \ ++ NewPtrClear(bytes + GC_page_size) + GC_page_size-1) ++# endif ++# else ++# ifdef MSWINCE ++ extern ptr_t GC_wince_get_mem(); ++# define GET_MEM(bytes) (struct hblk *)GC_wince_get_mem(bytes) ++# else ++# if defined(AMIGA) && defined(GC_AMIGA_FASTALLOC) ++ extern void *GC_amiga_get_mem(size_t size); ++ define GET_MEM(bytes) HBLKPTR((size_t) \ ++ GC_amiga_get_mem((size_t)bytes + GC_page_size) \ ++ + GC_page_size-1) ++# else ++ extern ptr_t GC_unix_get_mem(); ++# define GET_MEM(bytes) (struct hblk *)GC_unix_get_mem(bytes) ++# endif ++# endif ++# endif ++# endif ++# endif ++# endif ++# endif ++ ++#endif /* GC_PRIVATE_H */ + + # endif /* GCCONFIG_H */ +diff -urNb boehm-gc/include/private/pthread_stop_world.h boehm-gc/include/private/pthread_stop_world.h +--- boehm-gc/include/private/pthread_stop_world.h Wed Dec 31 16:00:00 1969 ++++ boehm-gc/include/private/pthread_stop_world.h Mon May 26 13:28:24 2003 +@@ -0,0 +1,12 @@ ++#ifndef GC_PTHREAD_STOP_WORLD_H ++#define GC_PTHREAD_STOP_WORLD_H ++ ++struct thread_stop_info { ++ int signal; ++ word last_stop_count; /* GC_last_stop_count value when thread */ ++ /* last successfully handled a suspend */ ++ /* signal. */ ++ ptr_t stack_ptr; /* Valid only when stopped. */ ++}; ++ ++#endif +diff -urNb boehm-gc/include/private/pthread_support.h boehm-gc/include/private/pthread_support.h +--- boehm-gc/include/private/pthread_support.h Wed Dec 31 16:00:00 1969 ++++ boehm-gc/include/private/pthread_support.h Mon May 26 13:28:24 2003 +@@ -0,0 +1,97 @@ ++#ifndef GC_PTHREAD_SUPPORT_H ++#define GC_PTHREAD_SUPPORT_H ++ ++# include "private/gc_priv.h" ++ ++# if defined(GC_PTHREADS) && !defined(GC_SOLARIS_THREADS) \ ++ && !defined(GC_IRIX_THREADS) && !defined(GC_WIN32_THREADS) ++ ++#if defined(GC_DARWIN_THREADS) ++# include "private/darwin_stop_world.h" ++#else ++# include "private/pthread_stop_world.h" ++#endif ++ ++/* We use the allocation lock to protect thread-related data structures. */ ++ ++/* The set of all known threads. We intercept thread creation and */ ++/* joins. */ ++/* Protected by allocation/GC lock. */ ++/* Some of this should be declared volatile, but that's inconsistent */ ++/* with some library routine declarations. */ ++typedef struct GC_Thread_Rep { ++ struct GC_Thread_Rep * next; /* More recently allocated threads */ ++ /* with a given pthread id come */ ++ /* first. (All but the first are */ ++ /* guaranteed to be dead, but we may */ ++ /* not yet have registered the join.) */ ++ pthread_t id; ++ /* Extra bookkeeping information the stopping code uses */ ++ struct thread_stop_info stop_info; ++ ++ short flags; ++# define FINISHED 1 /* Thread has exited. */ ++# define DETACHED 2 /* Thread is intended to be detached. */ ++# define MAIN_THREAD 4 /* True for the original thread only. */ ++ short thread_blocked; /* Protected by GC lock. */ ++ /* Treated as a boolean value. If set, */ ++ /* thread will acquire GC lock before */ ++ /* doing any pointer manipulations, and */ ++ /* has set its sp value. Thus it does */ ++ /* not need to be sent a signal to stop */ ++ /* it. */ ++ ptr_t stack_end; /* Cold end of the stack. */ ++# ifdef IA64 ++ ptr_t backing_store_end; ++ ptr_t backing_store_ptr; ++# endif ++ void * status; /* The value returned from the thread. */ ++ /* Used only to avoid premature */ ++ /* reclamation of any data it might */ ++ /* reference. */ ++# ifdef THREAD_LOCAL_ALLOC ++# if CPP_WORDSZ == 64 && defined(ALIGN_DOUBLE) ++# define GRANULARITY 16 ++# define NFREELISTS 49 ++# else ++# define GRANULARITY 8 ++# define NFREELISTS 65 ++# endif ++ /* The ith free list corresponds to size i*GRANULARITY */ ++# define INDEX_FROM_BYTES(n) ((ADD_SLOP(n) + GRANULARITY - 1)/GRANULARITY) ++# define BYTES_FROM_INDEX(i) ((i) * GRANULARITY - EXTRA_BYTES) ++# define SMALL_ENOUGH(bytes) (ADD_SLOP(bytes) <= \ ++ (NFREELISTS-1)*GRANULARITY) ++ ptr_t ptrfree_freelists[NFREELISTS]; ++ ptr_t normal_freelists[NFREELISTS]; ++# ifdef GC_GCJ_SUPPORT ++ ptr_t gcj_freelists[NFREELISTS]; ++# endif ++ /* Free lists contain either a pointer or a small count */ ++ /* reflecting the number of granules allocated at that */ ++ /* size. */ ++ /* 0 ==> thread-local allocation in use, free list */ ++ /* empty. */ ++ /* > 0, <= DIRECT_GRANULES ==> Using global allocation, */ ++ /* too few objects of this size have been */ ++ /* allocated by this thread. */ ++ /* >= HBLKSIZE => pointer to nonempty free list. */ ++ /* > DIRECT_GRANULES, < HBLKSIZE ==> transition to */ ++ /* local alloc, equivalent to 0. */ ++# define DIRECT_GRANULES (HBLKSIZE/GRANULARITY) ++ /* Don't use local free lists for up to this much */ ++ /* allocation. */ ++# endif ++} * GC_thread; ++ ++# define THREAD_TABLE_SZ 128 /* Must be power of 2 */ ++extern volatile GC_thread GC_threads[THREAD_TABLE_SZ]; ++ ++extern GC_bool GC_thr_initialized; ++ ++GC_thread GC_lookup_thread(pthread_t id); ++ ++void GC_stop_init(); ++ ++#endif /* GC_PTHREADS && !GC_SOLARIS_THREADS.... etc */ ++#endif /* GC_PTHREAD_SUPPORT_H */ +diff -urNb boehm-gc/include/private/solaris_threads.h boehm-gc/include/private/solaris_threads.h +--- boehm-gc/include/private/solaris_threads.h Tue Oct 23 16:21:39 2001 ++++ boehm-gc/include/private/solaris_threads.h Mon May 26 13:28:24 2003 +@@ -16,7 +16,8 @@ + # define DETACHED 2 /* Thread is intended to be detached. */ + # define CLIENT_OWNS_STACK 4 + /* Stack was supplied by client. */ +-# define SUSPENDED 8 /* Currently suspended. */ ++# define SUSPNDED 8 /* Currently suspended. */ ++ /* SUSPENDED is used insystem header. */ + ptr_t stack; + size_t stack_size; + cond_t join_cv; +diff -urNb boehm-gc/include/private/specific.h boehm-gc/include/private/specific.h +--- boehm-gc/include/private/specific.h Fri Mar 29 14:52:13 2002 ++++ boehm-gc/include/private/specific.h Mon May 26 13:28:24 2003 +@@ -85,7 +85,7 @@ + unsigned hash_val = CACHE_HASH(qtid); + tse * volatile * entry_ptr = key -> cache + hash_val; + tse * entry = *entry_ptr; /* Must be loaded only once. */ +- if (entry -> qtid == qtid) { ++ if (EXPECT(entry -> qtid == qtid, 1)) { + GC_ASSERT(entry -> thread == pthread_self()); + return entry -> value; + } +diff -urNb boehm-gc/irix_threads.c boehm-gc/irix_threads.c +--- boehm-gc/irix_threads.c Sun May 19 10:36:14 2002 ++++ boehm-gc/irix_threads.c Mon May 26 12:48:52 2003 +@@ -41,6 +41,10 @@ + #undef pthread_join + #undef pthread_detach + ++#ifdef HANDLE_FORK ++ --> Not yet supported. Try porting the code from linux_threads.c. ++#endif ++ + void GC_thr_init(); + + #if 0 +diff -urNb boehm-gc/mach_dep.c boehm-gc/mach_dep.c +--- boehm-gc/mach_dep.c Thu Jul 18 13:06:00 2002 ++++ boehm-gc/mach_dep.c Mon May 26 12:48:52 2003 +@@ -74,7 +74,7 @@ + /* on your architecture. Run the test_setjmp program to see whether */ + /* there is any chance it will work. */ + +-#ifndef USE_GENERIC_PUSH_REGS ++#if !defined(USE_GENERIC_PUSH_REGS) && !defined(USE_ASM_PUSH_REGS) + void GC_push_regs() + { + # ifdef RT +@@ -228,7 +228,8 @@ + || ( defined(I386) && defined(FREEBSD) && defined(__ELF__) ) \ + || ( defined(I386) && defined(NETBSD) && defined(__ELF__) ) \ + || ( defined(I386) && defined(OPENBSD) && defined(__ELF__) ) \ +- || ( defined(I386) && defined(HURD) && defined(__ELF__) ) ++ || ( defined(I386) && defined(HURD) && defined(__ELF__) ) \ ++ || ( defined(I386) && defined(DGUX) ) + + /* This is modified for Linux with ELF (Note: _ELF_ only) */ + /* This section handles FreeBSD with ELF. */ +@@ -377,7 +378,7 @@ + /* other machines... */ + # if !defined(M68K) && !defined(VAX) && !defined(RT) + # if !defined(SPARC) && !defined(I386) && !defined(NS32K) +-# if !defined(POWERPC) && !defined(UTS4) ++# if !(defined(POWERPC) && defined(LINUX)) && !defined(UTS4) + # if !defined(PJ) && !(defined(MIPS) && defined(LINUX)) + --> bad news <-- + # endif +@@ -385,7 +386,7 @@ + # endif + # endif + } +-#endif /* !USE_GENERIC_PUSH_REGS */ ++#endif /* !USE_GENERIC_PUSH_REGS && !USE_ASM_PUSH_REGS */ + + #if defined(USE_GENERIC_PUSH_REGS) + void GC_generic_push_regs(cold_gc_frame) +diff -urNb boehm-gc/malloc.c boehm-gc/malloc.c +--- boehm-gc/malloc.c Mon Feb 11 20:37:53 2002 ++++ boehm-gc/malloc.c Mon May 26 12:48:52 2003 +@@ -182,6 +182,7 @@ + ptr_t result; + DCL_LOCK_STATE; + ++ if (GC_have_errors) GC_print_all_errors(); + GC_INVOKE_FINALIZERS(); + if (SMALL_OBJ(lb)) { + DISABLE_SIGNALS(); +@@ -294,6 +295,11 @@ + return(GENERAL_MALLOC((word)lb, NORMAL)); + } + /* See above comment on signals. */ ++ GC_ASSERT(0 == obj_link(op) ++ || (word)obj_link(op) ++ <= (word)GC_greatest_plausible_heap_addr ++ && (word)obj_link(op) ++ >= (word)GC_least_plausible_heap_addr); + *opp = obj_link(op); + obj_link(op) = 0; + GC_words_allocd += lw; +@@ -338,6 +344,7 @@ + return((GC_PTR)REDIRECT_MALLOC(n*lb)); + } + ++#ifndef strdup + # include + # ifdef __STDC__ + char *strdup(const char *s) +@@ -346,11 +353,16 @@ + char *s; + # endif + { +- size_t len = strlen + 1; ++ size_t len = strlen(s) + 1; + char * result = ((char *)REDIRECT_MALLOC(len+1)); + BCOPY(s, result, len+1); + return result; + } ++#endif /* !defined(strdup) */ ++ /* If strdup is macro defined, we assume that it actually calls malloc, */ ++ /* and thus the right thing will happen even without overriding it. */ ++ /* This seems to be true on most Linux systems. */ ++ + # endif /* REDIRECT_MALLOC */ + + /* Explicitly deallocate an object p. */ +@@ -373,6 +385,7 @@ + /* Required by ANSI. It's not my fault ... */ + h = HBLKPTR(p); + hhdr = HDR(h); ++ GC_ASSERT(GC_base(p) == p); + # if defined(REDIRECT_MALLOC) && \ + (defined(GC_SOLARIS_THREADS) || defined(GC_LINUX_THREADS) \ + || defined(__MINGW32__)) /* Should this be MSWIN32 in general? */ +@@ -454,7 +467,10 @@ + } + #endif /* THREADS */ + +-# ifdef REDIRECT_MALLOC ++# if defined(REDIRECT_MALLOC) && !defined(REDIRECT_FREE) ++# define REDIRECT_FREE GC_free ++# endif ++# ifdef REDIRECT_FREE + # ifdef __STDC__ + void free(GC_PTR p) + # else +@@ -463,7 +479,7 @@ + # endif + { + # ifndef IGNORE_FREE +- GC_free(p); ++ REDIRECT_FREE(p); + # endif + } + # endif /* REDIRECT_MALLOC */ +diff -urNb boehm-gc/mallocx.c boehm-gc/mallocx.c +--- boehm-gc/mallocx.c Fri Aug 17 18:04:43 2001 ++++ boehm-gc/mallocx.c Mon May 26 12:48:52 2003 +@@ -142,7 +142,11 @@ + } + } + +-# if defined(REDIRECT_MALLOC) || defined(REDIRECT_REALLOC) ++# if defined(REDIRECT_MALLOC) && !defined(REDIRECT_REALLOC) ++# define REDIRECT_REALLOC GC_realloc ++# endif ++ ++# ifdef REDIRECT_REALLOC + # ifdef __STDC__ + GC_PTR realloc(GC_PTR p, size_t lb) + # else +@@ -151,13 +155,9 @@ + size_t lb; + # endif + { +-# ifdef REDIRECT_REALLOC + return(REDIRECT_REALLOC(p, lb)); +-# else +- return(GC_realloc(p, lb)); +-# endif + } +-# endif /* REDIRECT_MALLOC */ ++# endif /* REDIRECT_REALLOC */ + + + /* The same thing, except caller does not hold allocation lock. */ +@@ -177,6 +177,7 @@ + lw = ROUNDED_UP_WORDS(lb); + n_blocks = OBJ_SZ_TO_BLOCKS(lw); + init = GC_obj_kinds[k].ok_init; ++ if (GC_have_errors) GC_print_all_errors(); + GC_INVOKE_FINALIZERS(); + DISABLE_SIGNALS(); + LOCK(); +@@ -286,6 +287,7 @@ + register ptr_t op; + DCL_LOCK_STATE; + ++ if (GC_have_errors) GC_print_all_errors(); + GC_INVOKE_FINALIZERS(); + DISABLE_SIGNALS(); + LOCK(); +@@ -354,6 +356,7 @@ + return; + } + lw = ALIGNED_WORDS(lb); ++ if (GC_have_errors) GC_print_all_errors(); + GC_INVOKE_FINALIZERS(); + DISABLE_SIGNALS(); + LOCK(); +@@ -375,6 +378,7 @@ + while ((hbp = *rlh) != 0) { + hhdr = HDR(hbp); + *rlh = hhdr -> hb_next; ++ hhdr -> hb_last_reclaimed = (unsigned short) GC_gc_no; + # ifdef PARALLEL_MARK + { + signed_word my_words_allocd_tmp = GC_words_allocd_tmp; +@@ -574,6 +578,44 @@ + return((GC_PTR) op); + } + } ++ ++#ifdef __STDC__ ++/* Not well tested nor integrated. */ ++/* Debug version is tricky and currently missing. */ ++#include ++ ++GC_PTR GC_memalign(size_t align, size_t lb) ++{ ++ size_t new_lb; ++ size_t offset; ++ ptr_t result; ++ ++# ifdef ALIGN_DOUBLE ++ if (align <= WORDS_TO_BYTES(2) && lb > align) return GC_malloc(lb); ++# endif ++ if (align <= WORDS_TO_BYTES(1)) return GC_malloc(lb); ++ if (align >= HBLKSIZE/2 || lb >= HBLKSIZE/2) { ++ if (align > HBLKSIZE) return GC_oom_fn(LONG_MAX-1024) /* Fail */; ++ return GC_malloc(lb <= HBLKSIZE? HBLKSIZE : lb); ++ /* Will be HBLKSIZE aligned. */ ++ } ++ /* We could also try to make sure that the real rounded-up object size */ ++ /* is a multiple of align. That would be correct up to HBLKSIZE. */ ++ new_lb = lb + align - 1; ++ result = GC_malloc(new_lb); ++ offset = (word)result % align; ++ if (offset != 0) { ++ offset = align - offset; ++ if (!GC_all_interior_pointers) { ++ if (offset >= VALID_OFFSET_SZ) return GC_malloc(HBLKSIZE); ++ GC_register_displacement(offset); ++ } ++ } ++ result = (GC_PTR) ((ptr_t)result + offset); ++ GC_ASSERT((word)result % align == 0); ++ return result; ++} ++#endif + + # ifdef ATOMIC_UNCOLLECTABLE + /* Allocate lb bytes of pointerfree, untraced, uncollectable data */ +diff -urNb boehm-gc/mark.c boehm-gc/mark.c +--- boehm-gc/mark.c Fri Mar 29 14:52:12 2002 ++++ boehm-gc/mark.c Mon May 26 12:48:52 2003 +@@ -19,6 +19,10 @@ + # include + # include "private/gc_pmark.h" + ++#if defined(MSWIN32) && defined(__GNUC__) ++# include ++#endif ++ + /* We put this here to minimize the risk of inlining. */ + /*VARARGS*/ + #ifdef __WATCOMC__ +@@ -261,20 +265,20 @@ + /* remains valid until all marking is complete. */ + /* A zero value indicates that it's OK to miss some */ + /* register values. */ +-GC_bool GC_mark_some(cold_gc_frame) +-ptr_t cold_gc_frame; ++/* We hold the allocation lock. In the case of */ ++/* incremental collection, the world may not be stopped.*/ ++#ifdef MSWIN32 ++ /* For win32, this is called after we establish a structured */ ++ /* exception handler, in case Windows unmaps one of our root */ ++ /* segments. See below. In either case, we acquire the */ ++ /* allocator lock long before we get here. */ ++ GC_bool GC_mark_some_inner(cold_gc_frame) ++ ptr_t cold_gc_frame; ++#else ++ GC_bool GC_mark_some(cold_gc_frame) ++ ptr_t cold_gc_frame; ++#endif + { +-#if defined(MSWIN32) && !defined(__GNUC__) +- /* Windows 98 appears to asynchronously create and remove writable */ +- /* memory mappings, for reasons we haven't yet understood. Since */ +- /* we look for writable regions to determine the root set, we may */ +- /* try to mark from an address range that disappeared since we */ +- /* started the collection. Thus we have to recover from faults here. */ +- /* This code does not appear to be necessary for Windows 95/NT/2000. */ +- /* Note that this code should never generate an incremental GC write */ +- /* fault. */ +- __try { +-#endif /* defined(MSWIN32) && !defined(__GNUC__) */ + switch(GC_mark_state) { + case MS_NONE: + return(FALSE); +@@ -395,23 +399,130 @@ + ABORT("GC_mark_some: bad state"); + return(FALSE); + } +-#if defined(MSWIN32) && !defined(__GNUC__) ++} ++ ++ ++#ifdef MSWIN32 ++ ++# ifdef __GNUC__ ++ ++ typedef struct { ++ EXCEPTION_REGISTRATION ex_reg; ++ void *alt_path; ++ } ext_ex_regn; ++ ++ ++ static EXCEPTION_DISPOSITION mark_ex_handler( ++ struct _EXCEPTION_RECORD *ex_rec, ++ void *est_frame, ++ struct _CONTEXT *context, ++ void *disp_ctxt) ++ { ++ if (ex_rec->ExceptionCode == STATUS_ACCESS_VIOLATION) { ++ ext_ex_regn *xer = (ext_ex_regn *)est_frame; ++ ++ /* Unwind from the inner function assuming the standard */ ++ /* function prologue. */ ++ /* Assumes code has not been compiled with */ ++ /* -fomit-frame-pointer. */ ++ context->Esp = context->Ebp; ++ context->Ebp = *((DWORD *)context->Esp); ++ context->Esp = context->Esp - 8; ++ ++ /* Resume execution at the "real" handler within the */ ++ /* wrapper function. */ ++ context->Eip = (DWORD )(xer->alt_path); ++ ++ return ExceptionContinueExecution; ++ ++ } else { ++ return ExceptionContinueSearch; ++ } ++ } ++# endif /* __GNUC__ */ ++ ++ ++ GC_bool GC_mark_some(cold_gc_frame) ++ ptr_t cold_gc_frame; ++ { ++ GC_bool ret_val; ++ ++# ifndef __GNUC__ ++ /* Windows 98 appears to asynchronously create and remove */ ++ /* writable memory mappings, for reasons we haven't yet */ ++ /* understood. Since we look for writable regions to */ ++ /* determine the root set, we may try to mark from an */ ++ /* address range that disappeared since we started the */ ++ /* collection. Thus we have to recover from faults here. */ ++ /* This code does not appear to be necessary for Windows */ ++ /* 95/NT/2000. Note that this code should never generate */ ++ /* an incremental GC write fault. */ ++ ++ __try { ++ ++# else /* __GNUC__ */ ++ ++ /* Manually install an exception handler since GCC does */ ++ /* not yet support Structured Exception Handling (SEH) on */ ++ /* Win32. */ ++ ++ ext_ex_regn er; ++ ++ er.alt_path = &&handle_ex; ++ er.ex_reg.handler = mark_ex_handler; ++ asm volatile ("movl %%fs:0, %0" : "=r" (er.ex_reg.prev)); ++ asm volatile ("movl %0, %%fs:0" : : "r" (&er)); ++ ++# endif /* __GNUC__ */ ++ ++ ret_val = GC_mark_some_inner(cold_gc_frame); ++ ++# ifndef __GNUC__ ++ + } __except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ? + EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) { ++ ++# else /* __GNUC__ */ ++ ++ /* Prevent GCC from considering the following code unreachable */ ++ /* and thus eliminating it. */ ++ if (er.alt_path != 0) ++ goto rm_handler; ++ ++handle_ex: ++ /* Execution resumes from here on an access violation. */ ++ ++# endif /* __GNUC__ */ ++ + # ifdef CONDPRINT + if (GC_print_stats) { + GC_printf0("Caught ACCESS_VIOLATION in marker. " + "Memory mapping disappeared.\n"); + } + # endif /* CONDPRINT */ ++ + /* We have bad roots on the stack. Discard mark stack. */ + /* Rescan from marked objects. Redetermine roots. */ + GC_invalidate_mark_state(); + scan_ptr = 0; +- return FALSE; ++ ++ ret_val = FALSE; ++ ++# ifndef __GNUC__ ++ + } +-#endif /* defined(MSWIN32) && !defined(__GNUC__) */ +-} ++ ++# else /* __GNUC__ */ ++ ++rm_handler: ++ /* Uninstall the exception handler */ ++ asm volatile ("mov %0, %%fs:0" : : "r" (er.ex_reg.prev)); ++ ++# endif /* __GNUC__ */ ++ ++ return ret_val; ++ } ++#endif /* MSWIN32 */ + + + GC_bool GC_mark_stack_empty() +@@ -434,13 +545,7 @@ + /* for the large object. */ + /* - just return current if it does not point to a large object. */ + /*ARGSUSED*/ +-# ifdef PRINT_BLACK_LIST +- ptr_t GC_find_start(current, hhdr, new_hdr_p, source) +- ptr_t source; +-# else +- ptr_t GC_find_start(current, hhdr, new_hdr_p) +-# define source 0 +-# endif ++ptr_t GC_find_start(current, hhdr, new_hdr_p) + register ptr_t current; + register hdr *hhdr, **new_hdr_p; + { +@@ -468,7 +573,6 @@ + } else { + return(current); + } +-# undef source + } + + void GC_invalidate_mark_state() +@@ -546,8 +650,8 @@ + /* Large length. */ + /* Process part of the range to avoid pushing too much on the */ + /* stack. */ +- GC_ASSERT(descr < GC_greatest_plausible_heap_addr +- - GC_least_plausible_heap_addr); ++ GC_ASSERT(descr < (word)GC_greatest_plausible_heap_addr ++ - (word)GC_least_plausible_heap_addr); + # ifdef PARALLEL_MARK + # define SHARE_BYTES 2048 + if (descr > SHARE_BYTES && GC_parallel +@@ -578,6 +682,7 @@ + while (descr != 0) { + if ((signed_word)descr < 0) { + current = *current_p; ++ FIXUP_POINTER(current); + if ((ptr_t)current >= least_ha && (ptr_t)current < greatest_ha) { + PREFETCH(current); + HC_PUSH_CONTENTS((ptr_t)current, mark_stack_top, +@@ -652,6 +757,7 @@ + PREFETCH((ptr_t)limit - PREF_DIST*CACHE_LINE_SIZE); + GC_ASSERT(limit >= current_p); + deferred = *limit; ++ FIXUP_POINTER(deferred); + limit = (word *)((char *)limit - ALIGNMENT); + if ((ptr_t)deferred >= least_ha && (ptr_t)deferred < greatest_ha) { + PREFETCH(deferred); +@@ -661,6 +767,7 @@ + /* Unroll once, so we don't do too many of the prefetches */ + /* based on limit. */ + deferred = *limit; ++ FIXUP_POINTER(deferred); + limit = (word *)((char *)limit - ALIGNMENT); + if ((ptr_t)deferred >= least_ha && (ptr_t)deferred < greatest_ha) { + PREFETCH(deferred); +@@ -675,6 +782,7 @@ + /* Since HC_PUSH_CONTENTS expands to a lot of code, */ + /* we don't. */ + current = *current_p; ++ FIXUP_POINTER(current); + PREFETCH((ptr_t)current_p + PREF_DIST*CACHE_LINE_SIZE); + if ((ptr_t)current >= least_ha && (ptr_t)current < greatest_ha) { + /* Prefetch the contents of the object we just pushed. It's */ +@@ -726,22 +834,33 @@ + mse *top = local - 1; + unsigned i = 0; + ++ /* Make sure that prior writes to the mark stack are visible. */ ++ /* On some architectures, the fact that the reads are */ ++ /* volatile should suffice. */ ++# if !defined(IA64) && !defined(HP_PA) && !defined(I386) ++ GC_memory_barrier(); ++# endif + GC_ASSERT(high >= low-1 && high - low + 1 <= GC_mark_stack_size); + for (p = low; p <= high && i <= max; ++p) { + word descr = *(volatile word *) &(p -> mse_descr); ++ /* In the IA64 memory model, the following volatile store is */ ++ /* ordered after this read of descr. Thus a thread must read */ ++ /* the original nonzero value. HP_PA appears to be similar, */ ++ /* and if I'm reading the P4 spec correctly, X86 is probably */ ++ /* also OK. In some other cases we need a barrier. */ ++# if !defined(IA64) && !defined(HP_PA) && !defined(I386) ++ GC_memory_barrier(); ++# endif + if (descr != 0) { + *(volatile word *) &(p -> mse_descr) = 0; ++ /* More than one thread may get this entry, but that's only */ ++ /* a minor performance problem. */ + ++top; + top -> mse_descr = descr; + top -> mse_start = p -> mse_start; + GC_ASSERT( top -> mse_descr & GC_DS_TAGS != GC_DS_LENGTH || + top -> mse_descr < GC_greatest_plausible_heap_addr + - GC_least_plausible_heap_addr); +- /* There is no synchronization here. We assume that at */ +- /* least one thread will see the original descriptor. */ +- /* Otherwise we need a barrier. */ +- /* More than one thread may get this entry, but that's only */ +- /* a minor performance problem. */ + /* If this is a big object, count it as */ + /* size/256 + 1 objects. */ + ++i; +@@ -778,7 +897,7 @@ + BCOPY(low, my_start, stack_size * sizeof(mse)); + GC_ASSERT(GC_mark_stack_top = my_top); + # if !defined(IA64) && !defined(HP_PA) +- GC_memory_write_barrier(); ++ GC_memory_barrier(); + # endif + /* On IA64, the volatile write acts as a release barrier. */ + GC_mark_stack_top = my_top + stack_size; +@@ -1342,7 +1461,7 @@ + # define GC_least_plausible_heap_addr least_ha + + if (top == 0) return; +- /* check all pointers in range and put in push if they appear */ ++ /* check all pointers in range and push if they appear */ + /* to be valid. */ + lim = t - 1 /* longword */; + for (p = b; p <= lim; p = (word *)(((char *)p) + ALIGNMENT)) { +@@ -1366,7 +1485,7 @@ + ptr_t top; + ptr_t cold_gc_frame; + { +- if (GC_all_interior_pointers) { ++ if (!NEED_FIXUP_POINTER && GC_all_interior_pointers) { + # define EAGER_BYTES 1024 + /* Push the hot end of the stack eagerly, so that register values */ + /* saved inside GC frames are marked before they disappear. */ +@@ -1375,6 +1494,7 @@ + GC_push_all_stack(bottom, top); + return; + } ++ GC_ASSERT(bottom <= cold_gc_frame && cold_gc_frame <= top); + # ifdef STACK_GROWS_DOWN + GC_push_all(cold_gc_frame - sizeof(ptr_t), top); + GC_push_all_eager(bottom, cold_gc_frame); +@@ -1395,7 +1515,7 @@ + ptr_t bottom; + ptr_t top; + { +- if (GC_all_interior_pointers) { ++ if (!NEED_FIXUP_POINTER && GC_all_interior_pointers) { + GC_push_all(bottom, top); + } else { + GC_push_all_eager(bottom, top); +diff -urNb boehm-gc/mark_rts.c boehm-gc/mark_rts.c +--- boehm-gc/mark_rts.c Mon Mar 3 22:38:29 2003 ++++ boehm-gc/mark_rts.c Mon May 26 12:48:52 2003 +@@ -275,33 +275,72 @@ + } + + /* Internal use only; lock held. */ +-void GC_remove_tmp_roots() ++static void GC_remove_root_at_pos(i) ++int i; + { +- register int i; +- +- for (i = 0; i < n_root_sets; ) { +- if (GC_static_roots[i].r_tmp) { +- GC_root_size -= +- (GC_static_roots[i].r_end - GC_static_roots[i].r_start); ++ GC_root_size -= (GC_static_roots[i].r_end - GC_static_roots[i].r_start); + GC_static_roots[i].r_start = GC_static_roots[n_root_sets-1].r_start; + GC_static_roots[i].r_end = GC_static_roots[n_root_sets-1].r_end; + GC_static_roots[i].r_tmp = GC_static_roots[n_root_sets-1].r_tmp; + n_root_sets--; +- } else { +- i++; +- } +- } +-# if !defined(MSWIN32) && !defined(MSWINCE) +- { ++} ++ ++#if !defined(MSWIN32) && !defined(MSWINCE) ++static void GC_rebuild_root_index() ++{ + register int i; + + for (i = 0; i < RT_SIZE; i++) GC_root_index[i] = 0; + for (i = 0; i < n_root_sets; i++) + add_roots_to_index(GC_static_roots + i); ++} ++#endif ++ ++/* Internal use only; lock held. */ ++void GC_remove_tmp_roots() ++{ ++ register int i; ++ ++ for (i = 0; i < n_root_sets; ) { ++ if (GC_static_roots[i].r_tmp) { ++ GC_remove_root_at_pos(i); ++ } else { ++ i++; + } +-# endif ++ } ++ #if !defined(MSWIN32) && !defined(MSWINCE) ++ GC_rebuild_root_index(); ++ #endif ++} ++ ++#if !defined(MSWIN32) && !defined(MSWINCE) ++void GC_remove_roots(b, e) ++char * b; char * e; ++{ ++ DCL_LOCK_STATE; + ++ DISABLE_SIGNALS(); ++ LOCK(); ++ GC_remove_roots_inner(b, e); ++ UNLOCK(); ++ ENABLE_SIGNALS(); ++} ++ ++/* Should only be called when the lock is held */ ++void GC_remove_roots_inner(b,e) ++char * b; char * e; ++{ ++ int i; ++ for (i = 0; i < n_root_sets; ) { ++ if (GC_static_roots[i].r_start >= (ptr_t)b && GC_static_roots[i].r_end <= (ptr_t)e) { ++ GC_remove_root_at_pos(i); ++ } else { ++ i++; ++ } ++ } ++ GC_rebuild_root_index(); + } ++#endif /* !defined(MSWIN32) && !defined(MSWINCE) */ + + #if defined(MSWIN32) || defined(_WIN32_WCE_EMULATION) + /* Workaround for the OS mapping and unmapping behind our back: */ +@@ -573,8 +612,11 @@ + + /* Mark thread local free lists, even if their mark */ + /* descriptor excludes the link field. */ ++ /* If the world is not stopped, this is unsafe. It is */ ++ /* also unnecessary, since we will do this again with the */ ++ /* world stopped. */ + # ifdef THREAD_LOCAL_ALLOC +- GC_mark_thread_local_free_lists(); ++ if (GC_world_stopped) GC_mark_thread_local_free_lists(); + # endif + + /* +diff -urNb boehm-gc/misc.c boehm-gc/misc.c +--- boehm-gc/misc.c Mon Mar 3 22:38:30 2003 ++++ boehm-gc/misc.c Mon May 26 12:48:52 2003 +@@ -46,8 +46,10 @@ + # ifdef GC_SOLARIS_THREADS + mutex_t GC_allocate_ml; /* Implicitly initialized. */ + # else +-# ifdef GC_WIN32_THREADS +-# if !defined(GC_NOT_DLL) && (defined(_DLL) || defined(GC_DLL)) ++# if defined(GC_WIN32_THREADS) ++# if defined(GC_PTHREADS) ++ pthread_mutex_t GC_allocate_ml = PTHREAD_MUTEX_INITIALIZER; ++# elif defined(GC_DLL) + __declspec(dllexport) CRITICAL_SECTION GC_allocate_ml; + # else + CRITICAL_SECTION GC_allocate_ml; +@@ -90,6 +92,7 @@ + /* defined here so we don't have to load debug_malloc.o */ + + void (*GC_check_heap) GC_PROTO((void)) = (void (*) GC_PROTO((void)))0; ++void (*GC_print_all_smashed) GC_PROTO((void)) = (void (*) GC_PROTO((void)))0; + + void (*GC_start_call_back) GC_PROTO((void)) = (void (*) GC_PROTO((void)))0; + +@@ -109,6 +112,10 @@ + + GC_bool GC_print_back_height = 0; + ++#ifndef NO_DEBUGGING ++ GC_bool GC_dump_regularly = 0; /* Generate regular debugging dumps. */ ++#endif ++ + #ifdef FIND_LEAK + int GC_find_leak = 1; + #else +@@ -137,6 +144,13 @@ + + extern signed_word GC_mem_found; + ++void * GC_project2(arg1, arg2) ++void *arg1; ++void *arg2; ++{ ++ return arg2; ++} ++ + # ifdef MERGE_SIZES + /* Set things up so that GC_size_map[i] >= words(i), */ + /* but not too much bigger */ +@@ -455,7 +469,7 @@ + + DISABLE_SIGNALS(); + +-#ifdef MSWIN32 ++#if defined(GC_WIN32_THREADS) && !defined(GC_PTHREADS) + if (!GC_is_initialized) InitializeCriticalSection(&GC_allocate_ml); + #endif /* MSWIN32 */ + +@@ -473,6 +487,15 @@ + GC_init_parallel(); + } + # endif /* PARALLEL_MARK || THREAD_LOCAL_ALLOC */ ++ ++# if defined(DYNAMIC_LOADING) && defined(DARWIN) ++ { ++ /* This must be called WITHOUT the allocation lock held ++ and before any threads are created */ ++ extern void GC_init_dyld(); ++ GC_init_dyld(); ++ } ++# endif + } + + #if defined(MSWIN32) || defined(MSWINCE) +@@ -485,6 +508,22 @@ + + extern void GC_setpagesize(); + ++ ++#ifdef MSWIN32 ++extern GC_bool GC_no_win32_dlls; ++#else ++# define GC_no_win32_dlls FALSE ++#endif ++ ++void GC_exit_check GC_PROTO((void)) ++{ ++ GC_gcollect(); ++} ++ ++#ifdef SEARCH_FOR_DATA_START ++ extern void GC_init_linux_data_start GC_PROTO((void)); ++#endif ++ + #ifdef UNIX_LIKE + + extern void GC_set_and_save_fault_handler GC_PROTO((void (*handler)(int))); +@@ -495,12 +534,23 @@ + GC_err_printf1("Caught signal %d: looping in handler\n", sig); + for(;;); + } +-#endif + +-#ifdef MSWIN32 +-extern GC_bool GC_no_win32_dlls; +-#else +-# define GC_no_win32_dlls FALSE ++static GC_bool installed_looping_handler = FALSE; ++ ++void maybe_install_looping_handler() ++{ ++ /* Install looping handler before the write fault handler, so we */ ++ /* handle write faults correctly. */ ++ if (!installed_looping_handler && 0 != GETENV("GC_LOOP_ON_ABORT")) { ++ GC_set_and_save_fault_handler(looping_handler); ++ installed_looping_handler = TRUE; ++ } ++} ++ ++#else /* !UNIX_LIKE */ ++ ++# define maybe_install_looping_handler() ++ + #endif + + void GC_init_inner() +@@ -517,12 +567,19 @@ + # if defined(MSWIN32) || defined(MSWINCE) + InitializeCriticalSection(&GC_write_cs); + # endif +- + if (0 != GETENV("GC_PRINT_STATS")) { + GC_print_stats = 1; + } ++# ifndef NO_DEBUGGING ++ if (0 != GETENV("GC_DUMP_REGULARLY")) { ++ GC_dump_regularly = 1; ++ } ++# endif + if (0 != GETENV("GC_FIND_LEAK")) { + GC_find_leak = 1; ++# ifdef __STDC__ ++ atexit(GC_exit_check); ++# endif + } + if (0 != GETENV("GC_ALL_INTERIOR_POINTERS")) { + GC_all_interior_pointers = 1; +@@ -560,11 +617,7 @@ + } + } + } +-# ifdef UNIX_LIKE +- if (0 != GETENV("GC_LOOP_ON_ABORT")) { +- GC_set_and_save_fault_handler(looping_handler); +- } +-# endif ++ maybe_install_looping_handler(); + /* Adjust normal object descriptor for extra allocation. */ + if (ALIGNMENT > GC_DS_TAGS && EXTRA_BYTES != 0) { + GC_obj_kinds[NORMAL].ok_descriptor = ((word)(-ALIGNMENT) | GC_DS_LENGTH); +@@ -599,11 +652,21 @@ + # if defined(LINUX) && defined(IA64) + GC_register_stackbottom = GC_get_register_stack_base(); + # endif ++ } else { ++# if defined(LINUX) && defined(IA64) ++ if (GC_register_stackbottom == 0) { ++ WARN("GC_register_stackbottom should be set with GC_stackbottom", 0); ++ /* The following is likely to fail, since we rely on */ ++ /* alignment properties that may not hold with a user set */ ++ /* GC_stackbottom. */ ++ GC_register_stackbottom = GC_get_register_stack_base(); + } + # endif +- GC_ASSERT(sizeof (ptr_t) == sizeof(word)); +- GC_ASSERT(sizeof (signed_word) == sizeof(word)); +- GC_ASSERT(sizeof (struct hblk) == HBLKSIZE); ++ } ++# endif ++ GC_STATIC_ASSERT(sizeof (ptr_t) == sizeof(word)); ++ GC_STATIC_ASSERT(sizeof (signed_word) == sizeof(word)); ++ GC_STATIC_ASSERT(sizeof (struct hblk) == HBLKSIZE); + # ifndef THREADS + # if defined(STACK_GROWS_UP) && defined(STACK_GROWS_DOWN) + ABORT( +@@ -642,6 +705,18 @@ + initial_heap_sz = divHBLKSZ(initial_heap_sz); + } + } ++ { ++ char * sz_str = GETENV("GC_MAXIMUM_HEAP_SIZE"); ++ if (sz_str != NULL) { ++ word max_heap_sz = (word)atol(sz_str); ++ if (max_heap_sz < initial_heap_sz * HBLKSIZE) { ++ WARN("Bad maximum heap size %s - ignoring it.\n", ++ sz_str); ++ } ++ if (0 == GC_max_retries) GC_max_retries = 2; ++ GC_set_max_heap_size(max_heap_sz); ++ } ++ } + if (!GC_expand_hp_inner(initial_heap_sz)) { + GC_err_printf0("Can't start up: not enough memory\n"); + EXIT(); +@@ -677,6 +752,7 @@ + GC_incremental = TRUE; + } + # endif /* !SMALL_CONFIG */ ++ COND_DUMP; + /* Get black list set up and/or incrmental GC started */ + if (!GC_dont_precollect || GC_incremental) GC_gcollect_inner(); + GC_is_initialized = TRUE; +@@ -713,6 +789,7 @@ + GC_setpagesize(); + if (GC_no_win32_dlls) goto out; + # ifndef GC_SOLARIS_THREADS ++ maybe_install_looping_handler(); /* Before write fault handler! */ + GC_dirty_init(); + # endif + if (!GC_is_initialized) { +@@ -932,6 +1009,17 @@ + return(result); + } + ++# if defined(__STDC__) || defined(__cplusplus) ++ GC_word GC_set_free_space_divisor (GC_word value) ++# else ++ GC_word GC_set_free_space_divisor (value) ++ GC_word value; ++# endif ++{ ++ GC_word old = GC_free_space_divisor; ++ GC_free_space_divisor = value; ++ return old; ++} + + #ifndef PCR + void GC_abort(msg) +@@ -958,122 +1046,18 @@ + } + #endif + +-#ifdef NEED_CALLINFO +- +-#ifdef HAVE_BUILTIN_BACKTRACE +-# include +-# ifdef LINUX +-# include +-# endif +-#endif +- +-void GC_print_callers (info) +-struct callinfo info[NFRAMES]; +-{ +- register int i; +- +-# if NFRAMES == 1 +- GC_err_printf0("\tCaller at allocation:\n"); +-# else +- GC_err_printf0("\tCall chain at allocation:\n"); +-# endif +- for (i = 0; i < NFRAMES; i++) { +- if (info[i].ci_pc == 0) break; +-# if NARGS > 0 +- { +- int j; +- +- GC_err_printf0("\t\targs: "); +- for (j = 0; j < NARGS; j++) { +- if (j != 0) GC_err_printf0(", "); +- GC_err_printf2("%d (0x%X)", ~(info[i].ci_arg[j]), +- ~(info[i].ci_arg[j])); +- } +- GC_err_printf0("\n"); +- } +-# endif +-# if defined(HAVE_BUILTIN_BACKTRACE) && !defined(REDIRECT_MALLOC) +- /* Unfortunately backtrace_symbols calls malloc, which makes */ +- /* it dangersous if that has been redirected. */ +- { +- char **sym_name = +- backtrace_symbols((void **)(&(info[i].ci_pc)), 1); +- char *name = sym_name[0]; +- GC_bool found_it = (strchr(name, '(') != 0); +- FILE *pipe; +-# ifdef LINUX +- if (!found_it) { +-# define EXE_SZ 100 +- static char exe_name[EXE_SZ]; +-# define CMD_SZ 200 +- char cmd_buf[CMD_SZ]; +-# define RESULT_SZ 200 +- static char result_buf[RESULT_SZ]; +- size_t result_len; +- static GC_bool found_exe_name = FALSE; +- static GC_bool will_fail = FALSE; +- int ret_code; +- /* Unfortunately, this is the common case for the */ +- /* main executable. */ +- /* Try to get it via a hairy and expensive scheme. */ +- /* First we get the name of the executable: */ +- if (will_fail) goto out; +- if (!found_exe_name) { +- ret_code = readlink("/proc/self/exe", exe_name, EXE_SZ); +- if (ret_code < 0 || ret_code >= EXE_SZ || exe_name[0] != '/') { +- will_fail = TRUE; /* Dont try again. */ +- goto out; +- } +- exe_name[ret_code] = '\0'; +- found_exe_name = TRUE; +- } +- /* Then we use popen to start addr2line -e */ +- /* There are faster ways to do this, but hopefully this */ +- /* isn't time critical. */ +- sprintf(cmd_buf, "/usr/bin/addr2line -e %s 0x%lx", exe_name, +- (unsigned long)info[i].ci_pc); +- pipe = popen(cmd_buf, "r"); +- if (pipe < 0 || fgets(result_buf, RESULT_SZ, pipe) == 0) { +- will_fail = TRUE; +- goto out; +- } +- result_len = strlen(result_buf); +- if (result_buf[result_len - 1] == '\n') --result_len; +- if (result_buf[0] == '?' +- || result_buf[result_len-2] == ':' +- && result_buf[result_len-1] == '0') +- goto out; +- if (result_len < RESULT_SZ - 25) { +- /* Add in hex address */ +- sprintf(result_buf + result_len, " [0x%lx]", +- (unsigned long)info[i].ci_pc); +- } +- name = result_buf; +- pclose(pipe); +- out: +- } +-# endif +- GC_err_printf1("\t\t%s\n", name); +- free(sym_name); +- } +-# else +- GC_err_printf1("\t\t##PC##= 0x%lx\n", info[i].ci_pc); +-# endif +- } +-} +- +-#endif /* SAVE_CALL_CHAIN */ +- +-/* Needed by SRC_M3, gcj, and should perhaps be the official interface */ +-/* to GC_dont_gc. */ + void GC_enable() + { ++ LOCK(); + GC_dont_gc--; ++ UNLOCK(); + } + + void GC_disable() + { ++ LOCK(); + GC_dont_gc++; ++ UNLOCK(); + } + + #if !defined(NO_DEBUGGING) +@@ -1088,6 +1072,8 @@ + GC_print_hblkfreelist(); + GC_printf0("\n***Blocks in use:\n"); + GC_print_block_list(); ++ GC_printf0("\n***Finalization statistics:\n"); ++ GC_print_finalization_stats(); + } + + #endif /* NO_DEBUGGING */ +diff -urNb boehm-gc/os_dep.c boehm-gc/os_dep.c +--- boehm-gc/os_dep.c Fri Jul 19 01:54:43 2002 ++++ boehm-gc/os_dep.c Sat May 31 14:46:38 2003 +@@ -80,12 +80,15 @@ + # define NEED_FIND_LIMIT + # endif + +-#ifdef NEED_FIND_LIMIT +-# include +-#endif +- + #if defined(FREEBSD) && defined(I386) + # include ++# if !defined(PCR) ++# define NEED_FIND_LIMIT ++# endif ++#endif ++ ++#ifdef NEED_FIND_LIMIT ++# include + #endif + + #ifdef AMIGA +@@ -129,6 +132,11 @@ + # define jmp_buf sigjmp_buf + #endif + ++#ifdef DARWIN ++/* for get_etext and friends */ ++#include ++#endif ++ + #ifdef DJGPP + /* Apparently necessary for djgpp 2.01. May cause problems with */ + /* other versions. */ +@@ -147,6 +155,155 @@ + # define OPT_PROT_EXEC 0 + #endif + ++#if defined(LINUX) && \ ++ (defined(USE_PROC_FOR_LIBRARIES) || defined(IA64) || !defined(SMALL_CONFIG)) ++ ++/* We need to parse /proc/self/maps, either to find dynamic libraries, */ ++/* and/or to find the register backing store base (IA64). Do it once */ ++/* here. */ ++ ++#define READ read ++ ++/* Repeatedly perform a read call until the buffer is filled or */ ++/* we encounter EOF. */ ++ssize_t GC_repeat_read(int fd, char *buf, size_t count) ++{ ++ ssize_t num_read = 0; ++ ssize_t result; ++ ++ while (num_read < count) { ++ result = READ(fd, buf + num_read, count - num_read); ++ if (result < 0) return result; ++ if (result == 0) break; ++ num_read += result; ++ } ++ return num_read; ++} ++ ++/* ++ * Apply fn to a buffer containing the contents of /proc/self/maps. ++ * Return the result of fn or, if we failed, 0. ++ */ ++ ++word GC_apply_to_maps(word (*fn)(char *)) ++{ ++ int f; ++ int result; ++ int maps_size; ++ char maps_temp[32768]; ++ char *maps_buf; ++ ++ /* Read /proc/self/maps */ ++ /* Note that we may not allocate, and thus can't use stdio. */ ++ f = open("/proc/self/maps", O_RDONLY); ++ if (-1 == f) return 0; ++ /* stat() doesn't work for /proc/self/maps, so we have to ++ read it to find out how large it is... */ ++ maps_size = 0; ++ do { ++ result = GC_repeat_read(f, maps_temp, sizeof(maps_temp)); ++ if (result <= 0) return 0; ++ maps_size += result; ++ } while (result == sizeof(maps_temp)); ++ ++ if (maps_size > sizeof(maps_temp)) { ++ /* If larger than our buffer, close and re-read it. */ ++ close(f); ++ f = open("/proc/self/maps", O_RDONLY); ++ if (-1 == f) return 0; ++ maps_buf = alloca(maps_size); ++ if (NULL == maps_buf) return 0; ++ result = GC_repeat_read(f, maps_buf, maps_size); ++ if (result <= 0) return 0; ++ } else { ++ /* Otherwise use the fixed size buffer */ ++ maps_buf = maps_temp; ++ } ++ ++ close(f); ++ maps_buf[result] = '\0'; ++ ++ /* Apply fn to result. */ ++ return fn(maps_buf); ++} ++ ++#endif /* Need GC_apply_to_maps */ ++ ++#if defined(LINUX) && (defined(USE_PROC_FOR_LIBRARIES) || defined(IA64)) ++// ++// GC_parse_map_entry parses an entry from /proc/self/maps so we can ++// locate all writable data segments that belong to shared libraries. ++// The format of one of these entries and the fields we care about ++// is as follows: ++// XXXXXXXX-XXXXXXXX r-xp 00000000 30:05 260537 name of mapping...\n ++// ^^^^^^^^ ^^^^^^^^ ^^^^ ^^ ++// start end prot maj_dev ++// 0 9 18 32 ++// ++// For 64 bit ABIs: ++// 0 17 34 56 ++// ++// The parser is called with a pointer to the entry and the return value ++// is either NULL or is advanced to the next entry(the byte after the ++// trailing '\n'.) ++// ++#if CPP_WORDSZ == 32 ++# define OFFSET_MAP_START 0 ++# define OFFSET_MAP_END 9 ++# define OFFSET_MAP_PROT 18 ++# define OFFSET_MAP_MAJDEV 32 ++# define ADDR_WIDTH 8 ++#endif ++ ++#if CPP_WORDSZ == 64 ++# define OFFSET_MAP_START 0 ++# define OFFSET_MAP_END 17 ++# define OFFSET_MAP_PROT 34 ++# define OFFSET_MAP_MAJDEV 56 ++# define ADDR_WIDTH 16 ++#endif ++ ++/* ++ * Assign various fields of the first line in buf_ptr to *start, *end, ++ * *prot_buf and *maj_dev. Only *prot_buf may be set for unwritable maps. ++ */ ++char *GC_parse_map_entry(char *buf_ptr, word *start, word *end, ++ char *prot_buf, unsigned int *maj_dev) ++{ ++ int i; ++ char *tok; ++ ++ if (buf_ptr == NULL || *buf_ptr == '\0') { ++ return NULL; ++ } ++ ++ memcpy(prot_buf, buf_ptr+OFFSET_MAP_PROT, 4); // do the protections first ++ prot_buf[4] = '\0'; ++ ++ if (prot_buf[1] == 'w') { // we can skip all of this if it's not writable ++ ++ tok = buf_ptr; ++ buf_ptr[OFFSET_MAP_START+ADDR_WIDTH] = '\0'; ++ *start = strtoul(tok, NULL, 16); ++ ++ tok = buf_ptr+OFFSET_MAP_END; ++ buf_ptr[OFFSET_MAP_END+ADDR_WIDTH] = '\0'; ++ *end = strtoul(tok, NULL, 16); ++ ++ buf_ptr += OFFSET_MAP_MAJDEV; ++ tok = buf_ptr; ++ while (*buf_ptr != ':') buf_ptr++; ++ *buf_ptr++ = '\0'; ++ *maj_dev = strtoul(tok, NULL, 16); ++ } ++ ++ while (*buf_ptr && *buf_ptr++ != '\n'); ++ ++ return buf_ptr; ++} ++ ++#endif /* Need to parse /proc/self/maps. */ ++ + #if defined(SEARCH_FOR_DATA_START) + /* The I386 case can be handled without a search. The Alpha case */ + /* used to be handled differently as well, but the rules changed */ +@@ -154,6 +311,11 @@ + /* cover all versions. */ + + # ifdef LINUX ++ /* Some Linux distributions arrange to define __data_start. Some */ ++ /* define data_start as a weak symbol. The latter is technically */ ++ /* broken, since the user program may define data_start, in which */ ++ /* case we lose. Nonetheless, we try both, prefering __data_start. */ ++ /* We assume gcc-compatible pragmas. */ + # pragma weak __data_start + extern int __data_start[]; + # pragma weak data_start +@@ -169,16 +331,16 @@ + + # ifdef LINUX + /* Try the easy approaches first: */ +- if (__data_start != 0) { +- GC_data_start = (ptr_t)__data_start; ++ if ((ptr_t)__data_start != 0) { ++ GC_data_start = (ptr_t)(__data_start); + return; + } +- if (data_start != 0) { +- GC_data_start = (ptr_t)data_start; ++ if ((ptr_t)data_start != 0) { ++ GC_data_start = (ptr_t)(data_start); + return; + } + # endif /* LINUX */ +- GC_data_start = GC_find_limit((ptr_t)_end, FALSE); ++ GC_data_start = GC_find_limit((ptr_t)(_end), FALSE); + } + #endif + +@@ -617,7 +779,8 @@ + } + + /* Return the first nonaddressible location > p (up) or */ +- /* the smallest location q s.t. [q,p] is addressible (!up). */ ++ /* the smallest location q s.t. [q,p) is addressable (!up). */ ++ /* We assume that p (up) or p-1 (!up) is addressable. */ + ptr_t GC_find_limit(p, up) + ptr_t p; + GC_bool up; +@@ -650,18 +813,18 @@ + } + # endif + +-# if defined(ECOS) || defined(NOSYS) +-ptr_t GC_get_stack_base() +-{ ++#if defined(ECOS) || defined(NOSYS) ++ ptr_t GC_get_stack_base() ++ { + return STACKBOTTOM; +-} +- +-#else ++ } ++#endif + + #ifdef LINUX_STACKBOTTOM + + #include + #include ++#include + + # define STAT_SKIP 27 /* Number of fields preceding startstack */ + /* field in /proc/self/stat */ +@@ -670,6 +833,33 @@ + extern ptr_t __libc_stack_end; + + # ifdef IA64 ++ /* Try to read the backing store base from /proc/self/maps. */ ++ /* We look for the writable mapping with a 0 major device, */ ++ /* which is as close to our frame as possible, but below it.*/ ++ static word backing_store_base_from_maps(char *maps) ++ { ++ char prot_buf[5]; ++ char *buf_ptr = maps; ++ word start, end; ++ unsigned int maj_dev; ++ word current_best = 0; ++ word dummy; ++ ++ for (;;) { ++ buf_ptr = GC_parse_map_entry(buf_ptr, &start, &end, prot_buf, &maj_dev); ++ if (buf_ptr == NULL) return current_best; ++ if (prot_buf[1] == 'w' && maj_dev == 0) { ++ if (end < (word)(&dummy) && start > current_best) current_best = start; ++ } ++ } ++ return current_best; ++ } ++ ++ static word backing_store_base_from_proc(void) ++ { ++ return GC_apply_to_maps(backing_store_base_from_maps); ++ } ++ + # pragma weak __libc_ia64_register_backing_store_base + extern ptr_t __libc_ia64_register_backing_store_base; + +@@ -683,9 +873,15 @@ + /* Hence we check for both nonzero address and value. */ + return __libc_ia64_register_backing_store_base; + } else { +- word result = (word)GC_stackbottom - BACKING_STORE_DISPLACEMENT; ++ word result = backing_store_base_from_proc(); ++ if (0 == result) { ++ /* Use dumb heuristics. Works only for default configuration. */ ++ result = (word)GC_stackbottom - BACKING_STORE_DISPLACEMENT; + result += BACKING_STORE_ALIGNMENT - 1; + result &= ~(BACKING_STORE_ALIGNMENT - 1); ++ /* Verify that it's at least readable. If not, we goofed. */ ++ GC_noop1(*(word *)result); ++ } + return (ptr_t)result; + } + } +@@ -697,11 +893,8 @@ + /* using direct I/O system calls in order to avoid calling malloc */ + /* in case REDIRECT_MALLOC is defined. */ + # define STAT_BUF_SIZE 4096 +-# if defined(GC_USE_LD_WRAP) +-# define STAT_READ __real_read +-# else + # define STAT_READ read +-# endif ++ /* Should probably call the real read, if read is wrapped. */ + char stat_buf[STAT_BUF_SIZE]; + int f; + char c; +@@ -710,7 +903,16 @@ + + /* First try the easy way. This should work for glibc 2.2 */ + if (0 != &__libc_stack_end) { ++# ifdef IA64 ++ /* Some versions of glibc set the address 16 bytes too */ ++ /* low while the initialization code is running. */ ++ if (((word)__libc_stack_end & 0xfff) + 0x10 < 0x1000) { ++ return __libc_stack_end + 0x10; ++ } /* Otherwise it's not safe to add 16 bytes and we fall */ ++ /* back to using /proc. */ ++# else + return __libc_stack_end; ++# endif + } + f = open("/proc/self/stat", O_RDONLY); + if (f < 0 || STAT_READ(f, stat_buf, STAT_BUF_SIZE) < 2 * STAT_SKIP) { +@@ -764,8 +966,11 @@ + + ptr_t GC_get_stack_base() + { ++# if defined(HEURISTIC1) || defined(HEURISTIC2) || \ ++ defined(LINUX_STACKBOTTOM) || defined(FREEBSD_STACKBOTTOM) + word dummy; + ptr_t result; ++# endif + + # define STACKBOTTOM_ALIGNMENT_M1 ((word)STACK_GRAN - 1) + +@@ -814,7 +1019,6 @@ + return(result); + # endif /* STACKBOTTOM */ + } +-# endif /* NOSYS ECOS */ + + # endif /* ! AMIGA, !OS 2, ! MS Windows, !BEOS */ + +@@ -924,15 +1128,14 @@ + /* Unfortunately, we have to handle win32s very differently from NT, */ + /* Since VirtualQuery has very different semantics. In particular, */ + /* under win32s a VirtualQuery call on an unmapped page returns an */ +- /* invalid result. Under GC_register_data_segments is a noop and */ ++ /* invalid result. Under NT, GC_register_data_segments is a noop and */ + /* all real work is done by GC_register_dynamic_libraries. Under */ + /* win32s, we cannot find the data segments associated with dll's. */ +- /* We rgister the main data segment here. */ +-# ifdef __GCC__ +- GC_bool GC_no_win32_dlls = TRUE; /* GCC can't do SEH, so we can't use VirtualQuery */ +-# else ++ /* We register the main data segment here. */ + GC_bool GC_no_win32_dlls = FALSE; +-# endif ++ /* This used to be set for gcc, to avoid dealing with */ ++ /* the structured exception handling issues. But we now have */ ++ /* assembly code to do that right. */ + + void GC_init_win32() + { +@@ -965,35 +1168,101 @@ + } + # endif + +- /* Is p the start of either the malloc heap, or of one of our */ +- /* heap sections? */ +- GC_bool GC_is_heap_base (ptr_t p) +- { +- +- register unsigned i; +- + # ifndef REDIRECT_MALLOC +- static ptr_t malloc_heap_pointer = 0; ++ /* We maintain a linked list of AllocationBase values that we know */ ++ /* correspond to malloc heap sections. Currently this is only called */ ++ /* during a GC. But there is some hope that for long running */ ++ /* programs we will eventually see most heap sections. */ + +- if (0 == malloc_heap_pointer) { +- MEMORY_BASIC_INFORMATION buf; +- void *pTemp = malloc( 1 ); +- register DWORD result = VirtualQuery(pTemp, &buf, sizeof(buf)); ++ /* In the long run, it would be more reliable to occasionally walk */ ++ /* the malloc heap with HeapWalk on the default heap. But that */ ++ /* apparently works only for NT-based Windows. */ + +- free( pTemp ); ++ /* In the long run, a better data structure would also be nice ... */ ++ struct GC_malloc_heap_list { ++ void * allocation_base; ++ struct GC_malloc_heap_list *next; ++ } *GC_malloc_heap_l = 0; + ++ /* Is p the base of one of the malloc heap sections we already know */ ++ /* about? */ ++ GC_bool GC_is_malloc_heap_base(ptr_t p) ++ { ++ struct GC_malloc_heap_list *q = GC_malloc_heap_l; ++ ++ while (0 != q) { ++ if (q -> allocation_base == p) return TRUE; ++ q = q -> next; ++ } ++ return FALSE; ++ } + ++ void *GC_get_allocation_base(void *p) ++ { ++ MEMORY_BASIC_INFORMATION buf; ++ DWORD result = VirtualQuery(p, &buf, sizeof(buf)); + if (result != sizeof(buf)) { + ABORT("Weird VirtualQuery result"); + } +- malloc_heap_pointer = (ptr_t)(buf.AllocationBase); ++ return buf.AllocationBase; + } +- if (p == malloc_heap_pointer) return(TRUE); ++ ++ size_t GC_max_root_size = 100000; /* Appr. largest root size. */ ++ ++ void GC_add_current_malloc_heap() ++ { ++ struct GC_malloc_heap_list *new_l = ++ malloc(sizeof(struct GC_malloc_heap_list)); ++ void * candidate = GC_get_allocation_base(new_l); ++ ++ if (new_l == 0) return; ++ if (GC_is_malloc_heap_base(candidate)) { ++ /* Try a little harder to find malloc heap. */ ++ size_t req_size = 10000; ++ do { ++ void *p = malloc(req_size); ++ if (0 == p) { free(new_l); return; } ++ candidate = GC_get_allocation_base(p); ++ free(p); ++ req_size *= 2; ++ } while (GC_is_malloc_heap_base(candidate) ++ && req_size < GC_max_root_size/10 && req_size < 500000); ++ if (GC_is_malloc_heap_base(candidate)) { ++ free(new_l); return; ++ } ++ } ++# ifdef CONDPRINT ++ if (GC_print_stats) ++ GC_printf1("Found new system malloc AllocationBase at 0x%lx\n", ++ candidate); ++# endif ++ new_l -> allocation_base = candidate; ++ new_l -> next = GC_malloc_heap_l; ++ GC_malloc_heap_l = new_l; ++ } ++# endif /* REDIRECT_MALLOC */ ++ ++ /* Is p the start of either the malloc heap, or of one of our */ ++ /* heap sections? */ ++ GC_bool GC_is_heap_base (ptr_t p) ++ { ++ ++ unsigned i; ++ ++# ifndef REDIRECT_MALLOC ++ static word last_gc_no = -1; ++ ++ if (last_gc_no != GC_gc_no) { ++ GC_add_current_malloc_heap(); ++ last_gc_no = GC_gc_no; ++ } ++ if (GC_root_size > GC_max_root_size) GC_max_root_size = GC_root_size; ++ if (GC_is_malloc_heap_base(p)) return TRUE; + # endif + for (i = 0; i < GC_n_heap_bases; i++) { +- if (GC_heap_bases[i] == p) return(TRUE); ++ if (GC_heap_bases[i] == p) return TRUE; + } +- return(FALSE); ++ return FALSE ; + } + + # ifdef MSWIN32 +@@ -1043,7 +1312,7 @@ + + # if (defined(SVR4) || defined(AUX) || defined(DGUX) \ + || (defined(LINUX) && defined(SPARC))) && !defined(PCR) +-char * GC_SysVGetDataStart(max_page_size, etext_addr) ++ptr_t GC_SysVGetDataStart(max_page_size, etext_addr) + int max_page_size; + int * etext_addr; + { +@@ -1069,12 +1338,45 @@ + /* string constants in the text segment, but after etext. */ + /* Use plan B. Note that we now know there is a gap between */ + /* text and data segments, so plan A bought us something. */ +- result = (char *)GC_find_limit((ptr_t)(DATAEND) - MIN_PAGE_SIZE, FALSE); ++ result = (char *)GC_find_limit((ptr_t)(DATAEND), FALSE); + } +- return((char *)result); ++ return((ptr_t)result); + } + # endif + ++# if defined(FREEBSD) && defined(I386) && !defined(PCR) ++/* Its unclear whether this should be identical to the above, or */ ++/* whether it should apply to non-X86 architectures. */ ++/* For now we don't assume that there is always an empty page after */ ++/* etext. But in some cases there actually seems to be slightly more. */ ++/* This also deals with holes between read-only data and writable data. */ ++ptr_t GC_FreeBSDGetDataStart(max_page_size, etext_addr) ++int max_page_size; ++int * etext_addr; ++{ ++ word text_end = ((word)(etext_addr) + sizeof(word) - 1) ++ & ~(sizeof(word) - 1); ++ /* etext rounded to word boundary */ ++ VOLATILE word next_page = (text_end + (word)max_page_size - 1) ++ & ~((word)max_page_size - 1); ++ VOLATILE ptr_t result = (ptr_t)text_end; ++ GC_setup_temporary_fault_handler(); ++ if (setjmp(GC_jmp_buf) == 0) { ++ /* Try reading at the address. */ ++ /* This should happen before there is another thread. */ ++ for (; next_page < (word)(DATAEND); next_page += (word)max_page_size) ++ *(VOLATILE char *)next_page; ++ GC_reset_fault_handler(); ++ } else { ++ GC_reset_fault_handler(); ++ /* As above, we go to plan B */ ++ result = GC_find_limit((ptr_t)(DATAEND), FALSE); ++ } ++ return(result); ++} ++ ++# endif ++ + + #ifdef AMIGA + +@@ -1086,8 +1388,7 @@ + + void GC_register_data_segments() + { +-# if !defined(PCR) && !defined(SRC_M3) && !defined(NEXT) && !defined(MACOS) \ +- && !defined(MACOSX) ++# if !defined(PCR) && !defined(SRC_M3) && !defined(MACOS) + # if defined(REDIRECT_MALLOC) && defined(GC_SOLARIS_THREADS) + /* As of Solaris 2.3, the Solaris threads implementation */ + /* allocates the data structure for the initial thread with */ +@@ -1104,9 +1405,6 @@ + # endif + # endif + # endif +-# if !defined(PCR) && (defined(NEXT) || defined(MACOSX)) +- GC_add_roots_inner(DATASTART, (char *) get_end(), FALSE); +-# endif + # if defined(MACOS) + { + # if defined(THINK_C) +@@ -1216,18 +1514,28 @@ + ptr_t GC_unix_get_mem(bytes) + word bytes; + { +- static GC_bool initialized = FALSE; +- static int fd; + void *result; + static ptr_t last_addr = HEAP_START; + ++# ifndef USE_MMAP_ANON ++ static GC_bool initialized = FALSE; ++ static int fd; ++ + if (!initialized) { + fd = open("/dev/zero", O_RDONLY); ++ fcntl(fd, F_SETFD, FD_CLOEXEC); + initialized = TRUE; + } ++# endif ++ + if (bytes & (GC_page_size -1)) ABORT("Bad GET_MEM arg"); ++# ifdef USE_MMAP_ANON ++ result = mmap(last_addr, bytes, PROT_READ | PROT_WRITE | OPT_PROT_EXEC, ++ GC_MMAP_FLAGS | MAP_ANON, -1, 0/* offset */); ++# else + result = mmap(last_addr, bytes, PROT_READ | PROT_WRITE | OPT_PROT_EXEC, + GC_MMAP_FLAGS, fd, 0/* offset */); ++# endif + if (result == MAP_FAILED) return(0); + last_addr = (ptr_t)result + bytes + GC_page_size - 1; + last_addr = (ptr_t)((word)last_addr & ~(GC_page_size - 1)); +@@ -1322,7 +1630,15 @@ + result = (ptr_t) GlobalAlloc(0, bytes + HBLKSIZE); + result = (ptr_t)(((word)result + HBLKSIZE) & ~(HBLKSIZE-1)); + } else { +- result = (ptr_t) VirtualAlloc(NULL, bytes, ++ /* VirtualProtect only works on regions returned by a */ ++ /* single VirtualAlloc call. Thus we allocate one */ ++ /* extra page, which will prevent merging of blocks */ ++ /* in separate regions, and eliminate any temptation */ ++ /* to call VirtualProtect on a range spanning regions. */ ++ /* This wastes a small amount of memory, and risks */ ++ /* increased fragmentation. But better alternatives */ ++ /* would require effort. */ ++ result = (ptr_t) VirtualAlloc(NULL, bytes + 1, + MEM_COMMIT | MEM_RESERVE, + PAGE_EXECUTE_READWRITE); + } +@@ -1378,6 +1694,10 @@ + /* Reserve more pages */ + word res_bytes = (bytes + GC_sysinfo.dwAllocationGranularity-1) + & ~(GC_sysinfo.dwAllocationGranularity-1); ++ /* If we ever support MPROTECT_VDB here, we will probably need to */ ++ /* ensure that res_bytes is strictly > bytes, so that VirtualProtect */ ++ /* never spans regions. It seems to be OK for a VirtualFree argument */ ++ /* to span regions, so we should be OK for now. */ + result = (ptr_t) VirtualAlloc(NULL, res_bytes, + MEM_RESERVE | MEM_TOP_DOWN, + PAGE_EXECUTE_READWRITE); +@@ -1508,6 +1828,7 @@ + } + # else + if (-1 == zero_descr) zero_descr = open("/dev/zero", O_RDWR); ++ fcntl(zero_descr, F_SETFD, FD_CLOEXEC); + if (0 == start_addr) return; + result = mmap(start_addr, len, PROT_READ | PROT_WRITE | OPT_PROT_EXEC, + MAP_FIXED | MAP_PRIVATE, zero_descr, 0); +@@ -1694,7 +2015,6 @@ + * make sure that other system calls are similarly protected + * or write only to the stack. + */ +- + GC_bool GC_dirty_maintained = FALSE; + + # ifdef DEFAULT_VDB +@@ -1708,6 +2028,9 @@ + /* Initialize virtual dirty bit implementation. */ + void GC_dirty_init() + { ++#ifdef PRINTSTATS ++ GC_printf0("Initializing DEFAULT_VDB...\n"); ++#endif + GC_dirty_maintained = TRUE; + } + +@@ -1776,17 +2099,21 @@ + /* + * This implementation maintains dirty bits itself by catching write + * faults and keeping track of them. We assume nobody else catches +- * SIGBUS or SIGSEGV. We assume no write faults occur in system calls +- * except as a result of a read system call. This means clients must +- * either ensure that system calls do not touch the heap, or must +- * provide their own wrappers analogous to the one for read. ++ * SIGBUS or SIGSEGV. We assume no write faults occur in system calls. ++ * This means that clients must ensure that system calls don't write ++ * to the write-protected heap. Probably the best way to do this is to ++ * ensure that system calls write at most to POINTERFREE objects in the ++ * heap, and do even that only if we are on a platform on which those ++ * are not protected. Another alternative is to wrap system calls ++ * (see example for read below), but the current implementation holds ++ * a lock across blocking calls, making it problematic for multithreaded ++ * applications. + * We assume the page size is a multiple of HBLKSIZE. +- * This implementation is currently SunOS 4.X and IRIX 5.X specific, though we +- * tried to use portable code where easily possible. It is known +- * not to work under a number of other systems. ++ * We prefer them to be the same. We avoid protecting POINTERFREE ++ * objects only if they are the same. + */ + +-# if !defined(MSWIN32) && !defined(MSWINCE) ++# if !defined(MSWIN32) && !defined(MSWINCE) && !defined(DARWIN) + + # include + # include +@@ -1805,6 +2132,23 @@ + + # else + ++# ifdef DARWIN ++ /* Using vm_protect (mach syscall) over mprotect (BSD syscall) seems to ++ decrease the likelihood of some of the problems described below. */ ++ #include ++ extern mach_port_t GC_task_self; ++ #define PROTECT(addr,len) \ ++ if(vm_protect(GC_task_self,(vm_address_t)(addr),(vm_size_t)(len), \ ++ FALSE,VM_PROT_READ) != KERN_SUCCESS) { \ ++ ABORT("vm_portect failed"); \ ++ } ++ #define UNPROTECT(addr,len) \ ++ if(vm_protect(GC_task_self,(vm_address_t)(addr),(vm_size_t)(len), \ ++ FALSE,VM_PROT_READ|VM_PROT_WRITE) != KERN_SUCCESS) { \ ++ ABORT("vm_portect failed"); \ ++ } ++# else ++ + # ifndef MSWINCE + # include + # endif +@@ -1822,20 +2166,22 @@ + &protect_junk)) { \ + ABORT("un-VirtualProtect failed"); \ + } +- +-# endif ++# endif /* !DARWIN */ ++# endif /* MSWIN32 || MSWINCE || DARWIN */ + + #if defined(SUNOS4) || defined(FREEBSD) + typedef void (* SIG_PF)(); +-#endif ++#endif /* SUNOS4 || FREEBSD */ ++ + #if defined(SUNOS5SIGS) || defined(OSF1) || defined(LINUX) \ +- || defined(MACOSX) || defined(HURD) ++ || defined(HURD) + # ifdef __STDC__ + typedef void (* SIG_PF)(int); + # else + typedef void (* SIG_PF)(); + # endif +-#endif ++#endif /* SUNOS5SIGS || OSF1 || LINUX || HURD */ ++ + #if defined(MSWIN32) + typedef LPTOP_LEVEL_EXCEPTION_FILTER SIG_PF; + # undef SIG_DFL +@@ -1849,7 +2195,8 @@ + + #if defined(IRIX5) || defined(OSF1) || defined(HURD) + typedef void (* REAL_SIG_PF)(int, int, struct sigcontext *); +-#endif ++#endif /* IRIX5 || OSF1 || HURD */ ++ + #if defined(SUNOS5SIGS) + # ifdef HPUX + # define SIGINFO __siginfo +@@ -1861,13 +2208,14 @@ + # else + typedef void (* REAL_SIG_PF)(); + # endif +-#endif ++#endif /* SUNOS5SIGS */ ++ + #if defined(LINUX) + # if __GLIBC__ > 2 || __GLIBC__ == 2 && __GLIBC_MINOR__ >= 2 + typedef struct sigcontext s_c; + # else /* glibc < 2.2 */ + # include +-# if (LINUX_VERSION_CODE >= 0x20100) && !defined(M68K) || defined(ALPHA) ++# if (LINUX_VERSION_CODE >= 0x20100) && !defined(M68K) || defined(ALPHA) || defined(ARM32) + typedef struct sigcontext s_c; + # else + typedef struct sigcontext_struct s_c; +@@ -1895,139 +2243,14 @@ + return (char *)faultaddr; + } + # endif /* !ALPHA */ +-# endif +- +-# if defined(MACOSX) /* Should also test for PowerPC? */ +- typedef void (* REAL_SIG_PF)(int, int, struct sigcontext *); +- +-/* Decodes the machine instruction which was responsible for the sending of the +- SIGBUS signal. Sadly this is the only way to find the faulting address because +- the signal handler doesn't get it directly from the kernel (although it is +- available on the Mach level, but droppped by the BSD personality before it +- calls our signal handler...) +- This code should be able to deal correctly with all PPCs starting from the +- 601 up to and including the G4s (including Velocity Engine). */ +-#define EXTRACT_OP1(iw) (((iw) & 0xFC000000) >> 26) +-#define EXTRACT_OP2(iw) (((iw) & 0x000007FE) >> 1) +-#define EXTRACT_REGA(iw) (((iw) & 0x001F0000) >> 16) +-#define EXTRACT_REGB(iw) (((iw) & 0x03E00000) >> 21) +-#define EXTRACT_REGC(iw) (((iw) & 0x0000F800) >> 11) +-#define EXTRACT_DISP(iw) ((short *) &(iw))[1] +- +-static char *get_fault_addr(struct sigcontext *scp) +-{ +- unsigned int instr = *((unsigned int *) scp->sc_ir); +- unsigned int * regs = &((unsigned int *) scp->sc_regs)[2]; +- int disp = 0, tmp; +- unsigned int baseA = 0, baseB = 0; +- unsigned int addr, alignmask = 0xFFFFFFFF; +- +-#ifdef GC_DEBUG_DECODER +- GC_err_printf1("Instruction: 0x%lx\n", instr); +- GC_err_printf1("Opcode 1: d\n", (int)EXTRACT_OP1(instr)); +-#endif +- switch(EXTRACT_OP1(instr)) { +- case 38: /* stb */ +- case 39: /* stbu */ +- case 54: /* stfd */ +- case 55: /* stfdu */ +- case 52: /* stfs */ +- case 53: /* stfsu */ +- case 44: /* sth */ +- case 45: /* sthu */ +- case 47: /* stmw */ +- case 36: /* stw */ +- case 37: /* stwu */ +- tmp = EXTRACT_REGA(instr); +- if(tmp > 0) +- baseA = regs[tmp]; +- disp = EXTRACT_DISP(instr); +- break; +- case 31: +-#ifdef GC_DEBUG_DECODER +- GC_err_printf1("Opcode 2: %d\n", (int)EXTRACT_OP2(instr)); +-#endif +- switch(EXTRACT_OP2(instr)) { +- case 86: /* dcbf */ +- case 54: /* dcbst */ +- case 1014: /* dcbz */ +- case 247: /* stbux */ +- case 215: /* stbx */ +- case 759: /* stfdux */ +- case 727: /* stfdx */ +- case 983: /* stfiwx */ +- case 695: /* stfsux */ +- case 663: /* stfsx */ +- case 918: /* sthbrx */ +- case 439: /* sthux */ +- case 407: /* sthx */ +- case 661: /* stswx */ +- case 662: /* stwbrx */ +- case 150: /* stwcx. */ +- case 183: /* stwux */ +- case 151: /* stwx */ +- case 135: /* stvebx */ +- case 167: /* stvehx */ +- case 199: /* stvewx */ +- case 231: /* stvx */ +- case 487: /* stvxl */ +- tmp = EXTRACT_REGA(instr); +- if(tmp > 0) +- baseA = regs[tmp]; +- baseB = regs[EXTRACT_REGC(instr)]; +- /* determine Altivec alignment mask */ +- switch(EXTRACT_OP2(instr)) { +- case 167: /* stvehx */ +- alignmask = 0xFFFFFFFE; +- break; +- case 199: /* stvewx */ +- alignmask = 0xFFFFFFFC; +- break; +- case 231: /* stvx */ +- alignmask = 0xFFFFFFF0; +- break; +- case 487: /* stvxl */ +- alignmask = 0xFFFFFFF0; +- break; +- } +- break; +- case 725: /* stswi */ +- tmp = EXTRACT_REGA(instr); +- if(tmp > 0) +- baseA = regs[tmp]; +- break; +- default: /* ignore instruction */ +-#ifdef GC_DEBUG_DECODER +- GC_err_printf("Ignored by inner handler\n"); +-#endif +- return NULL; +- break; +- } +- break; +- default: /* ignore instruction */ +-#ifdef GC_DEBUG_DECODER +- GC_err_printf("Ignored by main handler\n"); +-#endif +- return NULL; +- break; +- } +- +- addr = (baseA + baseB) + disp; +- addr &= alignmask; +-#ifdef GC_DEBUG_DECODER +- GC_err_printf1("BaseA: %d\n", baseA); +- GC_err_printf1("BaseB: %d\n", baseB); +- GC_err_printf1("Disp: %d\n", disp); +- GC_err_printf1("Address: %d\n", addr); +-#endif +- return (char *)addr; +-} +-#endif /* MACOSX */ ++# endif /* LINUX */ + ++#ifndef DARWIN + SIG_PF GC_old_bus_handler; + SIG_PF GC_old_segv_handler; /* Also old MSWIN32 ACCESS_VIOLATION filter */ ++#endif /* !DARWIN */ + +-#ifdef THREADS ++#if defined(THREADS) + /* We need to lock around the bitmap update in the write fault handler */ + /* in order to avoid the risk of losing a bit. We do this with a */ + /* test-and-set spin lock if we know how to do that. Otherwise we */ +@@ -2076,6 +2299,7 @@ + #endif /* !THREADS */ + + /*ARGSUSED*/ ++#if !defined(DARWIN) + # if defined (SUNOS4) || defined(FREEBSD) + void GC_write_fault_handler(sig, code, scp, addr) + int sig, code; +@@ -2091,7 +2315,8 @@ + # define SIG_OK (sig == SIGBUS) + # define CODE_OK (code == BUS_PAGE_FAULT) + # endif +-# endif ++# endif /* SUNOS4 || FREEBSD */ ++ + # if defined(IRIX5) || defined(OSF1) || defined(HURD) + # include + void GC_write_fault_handler(int sig, int code, struct sigcontext *scp) +@@ -2107,7 +2332,8 @@ + # define SIG_OK (sig == SIGBUS || sig == SIGSEGV) + # define CODE_OK TRUE + # endif +-# endif ++# endif /* IRIX5 || OSF1 || HURD */ ++ + # if defined(LINUX) + # if defined(ALPHA) || defined(M68K) + void GC_write_fault_handler(int sig, int code, s_c * sc) +@@ -2115,15 +2341,20 @@ + # if defined(IA64) || defined(HP_PA) + void GC_write_fault_handler(int sig, siginfo_t * si, s_c * scp) + # else ++# if defined(ARM32) ++ void GC_write_fault_handler(int sig, int a2, int a3, int a4, s_c sc) ++# else + void GC_write_fault_handler(int sig, s_c sc) + # endif + # endif ++# endif + # define SIG_OK (sig == SIGSEGV) + # define CODE_OK TRUE + /* Empirically c.trapno == 14, on IA32, but is that useful? */ + /* Should probably consider alignment issues on other */ + /* architectures. */ +-# endif ++# endif /* LINUX */ ++ + # if defined(SUNOS5SIGS) + # ifdef __STDC__ + void GC_write_fault_handler(int sig, struct SIGINFO *scp, void * context) +@@ -2144,13 +2375,7 @@ + # define SIG_OK (sig == SIGSEGV) + # define CODE_OK (scp -> si_code == SEGV_ACCERR) + # endif +-# endif +- +-# if defined(MACOSX) +- void GC_write_fault_handler(int sig, int code, struct sigcontext *scp) +-# define SIG_OK (sig == SIGBUS) +-# define CODE_OK (code == 0 /* experimentally determined */) +-# endif ++# endif /* SUNOS5SIGS */ + + # if defined(MSWIN32) || defined(MSWINCE) + LONG WINAPI GC_write_fault_handler(struct _EXCEPTION_POINTERS *exc_info) +@@ -2158,7 +2383,7 @@ + STATUS_ACCESS_VIOLATION) + # define CODE_OK (exc_info -> ExceptionRecord -> ExceptionInformation[0] == 1) + /* Write fault */ +-# endif ++# endif /* MSWIN32 || MSWINCE */ + { + register unsigned i; + # if defined(HURD) +@@ -2218,6 +2443,9 @@ + # if defined(POWERPC) + char * addr = (char *) (sc.regs->dar); + # else ++# if defined(ARM32) ++ char * addr = (char *)sc.fault_address; ++# else + --> architecture not supported + # endif + # endif +@@ -2225,8 +2453,6 @@ + # endif + # endif + # endif +-# if defined(MACOSX) +- char * addr = get_fault_addr(scp); + # endif + # if defined(MSWIN32) || defined(MSWINCE) + char * addr = (char *) (exc_info -> ExceptionRecord +@@ -2291,9 +2517,6 @@ + (*(REAL_SIG_PF)old_handler) (sig, code, scp); + return; + # endif +-# ifdef MACOSX +- (*(REAL_SIG_PF)old_handler) (sig, code, scp); +-# endif + # ifdef MSWIN32 + return((*old_handler)(exc_info)); + # endif +@@ -2335,10 +2558,11 @@ + ABORT("Unexpected bus error or segmentation fault"); + #endif + } ++#endif /* !DARWIN */ + + /* + * We hold the allocation lock. We expect block h to be written +- * shortly. Ensure that all pages cvontaining any part of the n hblks ++ * shortly. Ensure that all pages containing any part of the n hblks + * starting at h are no longer protected. If is_ptrfree is false, + * also ensure that they will subsequently appear to be dirty. + */ +@@ -2367,6 +2591,7 @@ + UNPROTECT(h_trunc, (ptr_t)h_end - (ptr_t)h_trunc); + } + ++#if !defined(DARWIN) + void GC_dirty_init() + { + # if defined(SUNOS5SIGS) || defined(IRIX5) || defined(LINUX) || \ +@@ -2389,13 +2614,6 @@ + (void)sigaddset(&act.sa_mask, SIG_SUSPEND); + # endif /* SIG_SUSPEND */ + # endif +-# if defined(MACOSX) +- struct sigaction act, oldact; +- +- act.sa_flags = SA_RESTART; +- act.sa_handler = GC_write_fault_handler; +- sigemptyset(&act.sa_mask); +-# endif + # ifdef PRINTSTATS + GC_printf0("Inititalizing mprotect virtual dirty bit implementation\n"); + # endif +@@ -2435,9 +2653,12 @@ + sigaction(SIGSEGV, 0, &oldact); + sigaction(SIGSEGV, &act, 0); + # else +- sigaction(SIGSEGV, &act, &oldact); ++ { ++ int res = sigaction(SIGSEGV, &act, &oldact); ++ if (res != 0) ABORT("Sigaction failed"); ++ } + # endif +-# if defined(_sigargs) || defined(HURD) ++# if defined(_sigargs) || defined(HURD) || !defined(SA_SIGINFO) + /* This is Irix 5.x, not 6.x. Irix 5.x does not have */ + /* sa_sigaction. */ + GC_old_segv_handler = oldact.sa_handler; +@@ -2458,7 +2679,7 @@ + # endif + } + # endif +-# if defined(MACOSX) || defined(HPUX) || defined(LINUX) || defined(HURD) ++# if defined(HPUX) || defined(LINUX) || defined(HURD) + sigaction(SIGBUS, &act, &oldact); + GC_old_bus_handler = oldact.sa_handler; + if (GC_old_bus_handler == SIG_IGN) { +@@ -2470,7 +2691,7 @@ + GC_err_printf0("Replaced other SIGBUS handler\n"); + # endif + } +-# endif /* MACOS || HPUX || LINUX */ ++# endif /* HPUX || LINUX || HURD */ + # if defined(MSWIN32) + GC_old_segv_handler = SetUnhandledExceptionFilter(GC_write_fault_handler); + if (GC_old_segv_handler != NULL) { +@@ -2482,6 +2703,7 @@ + } + # endif + } ++#endif /* !DARWIN */ + + int GC_incremental_protection_needs() + { +@@ -2628,15 +2850,23 @@ + ((ptr_t)end_block - (ptr_t)start_block) + HBLKSIZE); + } + +-#if !defined(MSWIN32) && !defined(MSWINCE) && !defined(THREADS) \ +- && !defined(GC_USE_LD_WRAP) ++#if 0 ++ ++/* We no longer wrap read by default, since that was causing too many */ ++/* problems. It is preferred that the client instead avoids writing */ ++/* to the write-protected heap with a system call. */ ++/* This still serves as sample code if you do want to wrap system calls.*/ ++ ++#if !defined(MSWIN32) && !defined(MSWINCE) && !defined(GC_USE_LD_WRAP) + /* Replacement for UNIX system call. */ + /* Other calls that write to the heap should be handled similarly. */ + /* Note that this doesn't work well for blocking reads: It will hold */ +-/* tha allocation lock for the entur duration of the call. Multithreaded */ ++/* the allocation lock for the entire duration of the call. Multithreaded */ + /* clients should really ensure that it won't block, either by setting */ + /* the descriptor nonblocking, or by calling select or poll first, to */ + /* make sure that input is available. */ ++/* Another, preferred alternative is to ensure that system calls never */ ++/* write to the protected heap (see above). */ + # if defined(__STDC__) && !defined(SUNOS4) + # include + # include +@@ -2706,6 +2936,8 @@ + /* actually calls. */ + #endif + ++#endif /* 0 */ ++ + /*ARGSUSED*/ + GC_bool GC_page_was_ever_dirty(h) + struct hblk *h; +@@ -2721,13 +2953,6 @@ + { + } + +-# else /* !MPROTECT_VDB */ +- +-# ifdef GC_USE_LD_WRAP +- ssize_t __wrap_read(int fd, void *buf, size_t nbyte) +- { return __real_read(fd, buf, nbyte); } +-# endif +- + # endif /* MPROTECT_VDB */ + + # ifdef PROC_VDB +@@ -2806,6 +3031,7 @@ + } + GC_proc_fd = syscall(SYS_ioctl, fd, PIOCOPENPD, 0); + close(fd); ++ syscall(SYS_fcntl, GC_proc_fd, F_SETFD, FD_CLOEXEC); + if (GC_proc_fd < 0) { + ABORT("/proc ioctl failed"); + } +@@ -3045,6 +3271,553 @@ + + # endif /* PCR_VDB */ + ++#if defined(MPROTECT_VDB) && defined(DARWIN) ++/* The following sources were used as a *reference* for this exception handling ++ code: ++ 1. Apple's mach/xnu documentation ++ 2. Timothy J. Wood's "Mach Exception Handlers 101" post to the ++ omnigroup's macosx-dev list. ++ www.omnigroup.com/mailman/archive/macosx-dev/2000-June/002030.html ++ 3. macosx-nat.c from Apple's GDB source code. ++*/ ++ ++/* There seem to be numerous problems with darwin's mach exception handling. ++ I'm pretty sure they are not problems in my code. Search for ++ BROKEN_EXCEPTION_HANDLING for more information. */ ++#define BROKEN_EXCEPTION_HANDLING ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++/* These are not defined in any header, although they are documented */ ++extern boolean_t exc_server(mach_msg_header_t *,mach_msg_header_t *); ++extern kern_return_t exception_raise( ++ mach_port_t,mach_port_t,mach_port_t, ++ exception_type_t,exception_data_t,mach_msg_type_number_t); ++extern kern_return_t exception_raise_state( ++ mach_port_t,mach_port_t,mach_port_t, ++ exception_type_t,exception_data_t,mach_msg_type_number_t, ++ thread_state_flavor_t*,thread_state_t,mach_msg_type_number_t, ++ thread_state_t,mach_msg_type_number_t*); ++extern kern_return_t exception_raise_state_identity( ++ mach_port_t,mach_port_t,mach_port_t, ++ exception_type_t,exception_data_t,mach_msg_type_number_t, ++ thread_state_flavor_t*,thread_state_t,mach_msg_type_number_t, ++ thread_state_t,mach_msg_type_number_t*); ++ ++ ++#define MAX_EXCEPTION_PORTS 16 ++ ++static mach_port_t GC_task_self; ++ ++static struct { ++ mach_msg_type_number_t count; ++ exception_mask_t masks[MAX_EXCEPTION_PORTS]; ++ exception_handler_t ports[MAX_EXCEPTION_PORTS]; ++ exception_behavior_t behaviors[MAX_EXCEPTION_PORTS]; ++ thread_state_flavor_t flavors[MAX_EXCEPTION_PORTS]; ++} GC_old_exc_ports; ++ ++static struct { ++ mach_port_t exception; ++#if defined(THREADS) ++ mach_port_t reply; ++#endif ++} GC_ports; ++ ++typedef struct { ++ mach_msg_header_t head; ++} GC_msg_t; ++ ++typedef enum { ++ GC_MP_NORMAL, GC_MP_DISCARDING, GC_MP_STOPPED ++} GC_mprotect_state_t; ++ ++/* FIXME: 1 and 2 seem to be safe to use in the msgh_id field, ++ but it isn't documented. Use the source and see if they ++ should be ok. */ ++#define ID_STOP 1 ++#define ID_RESUME 2 ++ ++/* These values are only used on the reply port */ ++#define ID_ACK 3 ++ ++#if defined(THREADS) ++ ++GC_mprotect_state_t GC_mprotect_state; ++ ++/* The following should ONLY be called when the world is stopped */ ++static void GC_mprotect_thread_notify(mach_msg_id_t id) { ++ struct { ++ GC_msg_t msg; ++ mach_msg_trailer_t trailer; ++ } buf; ++ mach_msg_return_t r; ++ /* remote, local */ ++ buf.msg.head.msgh_bits = ++ MACH_MSGH_BITS(MACH_MSG_TYPE_MAKE_SEND,0); ++ buf.msg.head.msgh_size = sizeof(buf.msg); ++ buf.msg.head.msgh_remote_port = GC_ports.exception; ++ buf.msg.head.msgh_local_port = MACH_PORT_NULL; ++ buf.msg.head.msgh_id = id; ++ ++ r = mach_msg( ++ &buf.msg.head, ++ MACH_SEND_MSG|MACH_RCV_MSG|MACH_RCV_LARGE, ++ sizeof(buf.msg), ++ sizeof(buf), ++ GC_ports.reply, ++ MACH_MSG_TIMEOUT_NONE, ++ MACH_PORT_NULL); ++ if(r != MACH_MSG_SUCCESS) ++ ABORT("mach_msg failed in GC_mprotect_thread_notify"); ++ if(buf.msg.head.msgh_id != ID_ACK) ++ ABORT("invalid ack in GC_mprotect_thread_notify"); ++} ++ ++/* Should only be called by the mprotect thread */ ++static void GC_mprotect_thread_reply() { ++ GC_msg_t msg; ++ mach_msg_return_t r; ++ /* remote, local */ ++ msg.head.msgh_bits = ++ MACH_MSGH_BITS(MACH_MSG_TYPE_MAKE_SEND,0); ++ msg.head.msgh_size = sizeof(msg); ++ msg.head.msgh_remote_port = GC_ports.reply; ++ msg.head.msgh_local_port = MACH_PORT_NULL; ++ msg.head.msgh_id = ID_ACK; ++ ++ r = mach_msg( ++ &msg.head, ++ MACH_SEND_MSG, ++ sizeof(msg), ++ 0, ++ MACH_PORT_NULL, ++ MACH_MSG_TIMEOUT_NONE, ++ MACH_PORT_NULL); ++ if(r != MACH_MSG_SUCCESS) ++ ABORT("mach_msg failed in GC_mprotect_thread_reply"); ++} ++ ++void GC_mprotect_stop() { ++ GC_mprotect_thread_notify(ID_STOP); ++} ++void GC_mprotect_resume() { ++ GC_mprotect_thread_notify(ID_RESUME); ++} ++ ++#else /* !THREADS */ ++/* The compiler should optimize away any GC_mprotect_state computations */ ++#define GC_mprotect_state GC_MP_NORMAL ++#endif ++ ++static void *GC_mprotect_thread(void *arg) { ++ mach_msg_return_t r; ++ /* These two structures contain some private kernel data. We don't need to ++ access any of it so we don't bother defining a proper struct. The ++ correct definitions are in the xnu source code. */ ++ struct { ++ mach_msg_header_t head; ++ char data[256]; ++ } reply; ++ struct { ++ mach_msg_header_t head; ++ mach_msg_body_t msgh_body; ++ char data[1024]; ++ } msg; ++ ++ mach_msg_id_t id; ++ ++ for(;;) { ++ r = mach_msg( ++ &msg.head, ++ MACH_RCV_MSG|MACH_RCV_LARGE| ++ (GC_mprotect_state == GC_MP_DISCARDING ? MACH_RCV_TIMEOUT : 0), ++ 0, ++ sizeof(msg), ++ GC_ports.exception, ++ GC_mprotect_state == GC_MP_DISCARDING ? 0 : MACH_MSG_TIMEOUT_NONE, ++ MACH_PORT_NULL); ++ ++ id = r == MACH_MSG_SUCCESS ? msg.head.msgh_id : -1; ++ ++#if defined(THREADS) ++ if(GC_mprotect_state == GC_MP_DISCARDING) { ++ if(r == MACH_RCV_TIMED_OUT) { ++ GC_mprotect_state = GC_MP_STOPPED; ++ GC_mprotect_thread_reply(); ++ continue; ++ } ++ if(r == MACH_MSG_SUCCESS && (id == ID_STOP || id == ID_RESUME)) ++ ABORT("out of order mprotect thread request"); ++ } ++#endif ++ ++ if(r != MACH_MSG_SUCCESS) { ++ GC_err_printf2("mach_msg failed with %d %s\n", ++ (int)r,mach_error_string(r)); ++ ABORT("mach_msg failed"); ++ } ++ ++ switch(id) { ++#if defined(THREADS) ++ case ID_STOP: ++ if(GC_mprotect_state != GC_MP_NORMAL) ++ ABORT("Called mprotect_stop when state wasn't normal"); ++ GC_mprotect_state = GC_MP_DISCARDING; ++ break; ++ case ID_RESUME: ++ if(GC_mprotect_state != GC_MP_STOPPED) ++ ABORT("Called mprotect_resume when state wasn't stopped"); ++ GC_mprotect_state = GC_MP_NORMAL; ++ GC_mprotect_thread_reply(); ++ break; ++#endif /* THREADS */ ++ default: ++ /* Handle the message (calls catch_exception_raise) */ ++ if(!exc_server(&msg.head,&reply.head)) ++ ABORT("exc_server failed"); ++ /* Send the reply */ ++ r = mach_msg( ++ &reply.head, ++ MACH_SEND_MSG, ++ reply.head.msgh_size, ++ 0, ++ MACH_PORT_NULL, ++ MACH_MSG_TIMEOUT_NONE, ++ MACH_PORT_NULL); ++ if(r != MACH_MSG_SUCCESS) { ++ /* This will fail if the thread dies, but the thread shouldn't ++ die... */ ++ #ifdef BROKEN_EXCEPTION_HANDLING ++ GC_err_printf2( ++ "mach_msg failed with %d %s while sending exc reply\n", ++ (int)r,mach_error_string(r)); ++ #else ++ ABORT("mach_msg failed while sending exception reply"); ++ #endif ++ } ++ } /* switch */ ++ } /* for(;;) */ ++ /* NOT REACHED */ ++ return NULL; ++} ++ ++/* All this SIGBUS code shouldn't be necessary. All protection faults should ++ be going throught the mach exception handler. However, it seems a SIGBUS is ++ occasionally sent for some unknown reason. Even more odd, it seems to be ++ meaningless and safe to ignore. */ ++#ifdef BROKEN_EXCEPTION_HANDLING ++ ++typedef void (* SIG_PF)(); ++static SIG_PF GC_old_bus_handler; ++ ++/* Updates to this aren't atomic, but the SIGBUSs seem pretty rare. ++ Even if this doesn't get updated property, it isn't really a problem */ ++static int GC_sigbus_count; ++ ++static void GC_darwin_sigbus(int num,siginfo_t *sip,void *context) { ++ if(num != SIGBUS) ABORT("Got a non-sigbus signal in the sigbus handler"); ++ ++ /* Ugh... some seem safe to ignore, but too many in a row probably means ++ trouble. GC_sigbus_count is reset for each mach exception that is ++ handled */ ++ if(GC_sigbus_count >= 8) { ++ ABORT("Got more than 8 SIGBUSs in a row!"); ++ } else { ++ GC_sigbus_count++; ++ GC_err_printf0("GC: WARNING: Ignoring SIGBUS.\n"); ++ } ++} ++#endif /* BROKEN_EXCEPTION_HANDLING */ ++ ++void GC_dirty_init() { ++ kern_return_t r; ++ mach_port_t me; ++ pthread_t thread; ++ pthread_attr_t attr; ++ exception_mask_t mask; ++ ++# ifdef PRINTSTATS ++ GC_printf0("Inititalizing mach/darwin mprotect virtual dirty bit " ++ "implementation\n"); ++# endif ++# ifdef BROKEN_EXCEPTION_HANDLING ++ GC_err_printf0("GC: WARNING: Enabling workarounds for various darwin " ++ "exception handling bugs.\n"); ++# endif ++ GC_dirty_maintained = TRUE; ++ if (GC_page_size % HBLKSIZE != 0) { ++ GC_err_printf0("Page size not multiple of HBLKSIZE\n"); ++ ABORT("Page size not multiple of HBLKSIZE"); ++ } ++ ++ GC_task_self = me = mach_task_self(); ++ ++ r = mach_port_allocate(me,MACH_PORT_RIGHT_RECEIVE,&GC_ports.exception); ++ if(r != KERN_SUCCESS) ABORT("mach_port_allocate failed (exception port)"); ++ ++ r = mach_port_insert_right(me,GC_ports.exception,GC_ports.exception, ++ MACH_MSG_TYPE_MAKE_SEND); ++ if(r != KERN_SUCCESS) ++ ABORT("mach_port_insert_right failed (exception port)"); ++ ++ #if defined(THREADS) ++ r = mach_port_allocate(me,MACH_PORT_RIGHT_RECEIVE,&GC_ports.reply); ++ if(r != KERN_SUCCESS) ABORT("mach_port_allocate failed (reply port)"); ++ #endif ++ ++ /* The exceptions we want to catch */ ++ mask = EXC_MASK_BAD_ACCESS; ++ ++ r = task_get_exception_ports( ++ me, ++ mask, ++ GC_old_exc_ports.masks, ++ &GC_old_exc_ports.count, ++ GC_old_exc_ports.ports, ++ GC_old_exc_ports.behaviors, ++ GC_old_exc_ports.flavors ++ ); ++ if(r != KERN_SUCCESS) ABORT("task_get_exception_ports failed"); ++ ++ r = task_set_exception_ports( ++ me, ++ mask, ++ GC_ports.exception, ++ EXCEPTION_DEFAULT, ++ MACHINE_THREAD_STATE ++ ); ++ if(r != KERN_SUCCESS) ABORT("task_set_exception_ports failed"); ++ ++ if(pthread_attr_init(&attr) != 0) ABORT("pthread_attr_init failed"); ++ if(pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED) != 0) ++ ABORT("pthread_attr_setdetachedstate failed"); ++ ++# undef pthread_create ++ /* This will call the real pthread function, not our wrapper */ ++ if(pthread_create(&thread,&attr,GC_mprotect_thread,NULL) != 0) ++ ABORT("pthread_create failed"); ++ pthread_attr_destroy(&attr); ++ ++ /* Setup the sigbus handler for ignoring the meaningless SIGBUSs */ ++ #ifdef BROKEN_EXCEPTION_HANDLING ++ { ++ struct sigaction sa, oldsa; ++ sa.sa_handler = (SIG_PF)GC_darwin_sigbus; ++ sigemptyset(&sa.sa_mask); ++ sa.sa_flags = SA_RESTART|SA_SIGINFO; ++ if(sigaction(SIGBUS,&sa,&oldsa) < 0) ABORT("sigaction"); ++ GC_old_bus_handler = (SIG_PF)oldsa.sa_handler; ++ if (GC_old_bus_handler != SIG_DFL) { ++# ifdef PRINTSTATS ++ GC_err_printf0("Replaced other SIGBUS handler\n"); ++# endif ++ } ++ } ++ #endif /* BROKEN_EXCEPTION_HANDLING */ ++} ++ ++/* The source code for Apple's GDB was used as a reference for the exception ++ forwarding code. This code is similar to be GDB code only because there is ++ only one way to do it. */ ++static kern_return_t GC_forward_exception( ++ mach_port_t thread, ++ mach_port_t task, ++ exception_type_t exception, ++ exception_data_t data, ++ mach_msg_type_number_t data_count ++) { ++ int i; ++ kern_return_t r; ++ mach_port_t port; ++ exception_behavior_t behavior; ++ thread_state_flavor_t flavor; ++ ++ thread_state_data_t thread_state; ++ mach_msg_type_number_t thread_state_count = THREAD_STATE_MAX; ++ ++ for(i=0;i 0 ? code[0] : -1, ++ code_count > 1 ? code[1] : -1); ++ #endif ++ return FWD(); ++ } ++ ++ r = thread_get_state(thread,flavor, ++ (natural_t*)&exc_state,&exc_state_count); ++ if(r != KERN_SUCCESS) { ++ /* The thread is supposed to be suspended while the exception handler ++ is called. This shouldn't fail. */ ++ #ifdef BROKEN_EXCEPTION_HANDLING ++ GC_err_printf0("thread_get_state failed in " ++ "catch_exception_raise\n"); ++ return KERN_SUCCESS; ++ #else ++ ABORT("thread_get_state failed in catch_exception_raise"); ++ #endif ++ } ++ ++ /* This is the address that caused the fault */ ++ addr = (char*) exc_state.dar; ++ ++ if((HDR(addr)) == 0) { ++ /* Ugh... just like the SIGBUS problem above, it seems we get a bogus ++ KERN_PROTECTION_FAILURE every once and a while. We wait till we get ++ a bunch in a row before doing anything about it. If a "real" fault ++ ever occurres it'll just keep faulting over and over and we'll hit ++ the limit pretty quickly. */ ++ #ifdef BROKEN_EXCEPTION_HANDLING ++ static char *last_fault; ++ static int last_fault_count; ++ ++ if(addr != last_fault) { ++ last_fault = addr; ++ last_fault_count = 0; ++ } ++ if(++last_fault_count < 32) { ++ if(last_fault_count == 1) ++ GC_err_printf1( ++ "GC: WARNING: Ignoring KERN_PROTECTION_FAILURE at %p\n", ++ addr); ++ return KERN_SUCCESS; ++ } ++ ++ GC_err_printf1("Unexpected KERN_PROTECTION_FAILURE at %p\n",addr); ++ /* Can't pass it along to the signal handler because that is ++ ignoring SIGBUS signals. We also shouldn't call ABORT here as ++ signals don't always work too well from the exception handler. */ ++ GC_err_printf0("Aborting\n"); ++ exit(EXIT_FAILURE); ++ #else /* BROKEN_EXCEPTION_HANDLING */ ++ /* Pass it along to the next exception handler ++ (which should call SIGBUS/SIGSEGV) */ ++ return FWD(); ++ #endif /* !BROKEN_EXCEPTION_HANDLING */ ++ } ++ ++ #ifdef BROKEN_EXCEPTION_HANDLING ++ /* Reset the number of consecutive SIGBUSs */ ++ GC_sigbus_count = 0; ++ #endif ++ ++ if(GC_mprotect_state == GC_MP_NORMAL) { /* common case */ ++ h = (struct hblk*)((word)addr & ~(GC_page_size-1)); ++ UNPROTECT(h, GC_page_size); ++ for (i = 0; i < divHBLKSZ(GC_page_size); i++) { ++ register int index = PHT_HASH(h+i); ++ async_set_pht_entry_from_index(GC_dirty_pages, index); ++ } ++ } else if(GC_mprotect_state == GC_MP_DISCARDING) { ++ /* Lie to the thread for now. No sense UNPROTECT()ing the memory ++ when we're just going to PROTECT() it again later. The thread ++ will just fault again once it resumes */ ++ } else { ++ /* Shouldn't happen, i don't think */ ++ GC_printf0("KERN_PROTECTION_FAILURE while world is stopped\n"); ++ return FWD(); ++ } ++ return KERN_SUCCESS; ++} ++#undef FWD ++ ++/* These should never be called, but just in case... */ ++kern_return_t catch_exception_raise_state(mach_port_name_t exception_port, ++ int exception, exception_data_t code, mach_msg_type_number_t codeCnt, ++ int flavor, thread_state_t old_state, int old_stateCnt, ++ thread_state_t new_state, int new_stateCnt) ++{ ++ ABORT("catch_exception_raise_state"); ++ return(KERN_INVALID_ARGUMENT); ++} ++kern_return_t catch_exception_raise_state_identity( ++ mach_port_name_t exception_port, mach_port_t thread, mach_port_t task, ++ int exception, exception_data_t code, mach_msg_type_number_t codeCnt, ++ int flavor, thread_state_t old_state, int old_stateCnt, ++ thread_state_t new_state, int new_stateCnt) ++{ ++ ABORT("catch_exception_raise_state_identity"); ++ return(KERN_INVALID_ARGUMENT); ++} ++ ++ ++#endif /* DARWIN && MPROTECT_VDB */ ++ + # ifndef HAVE_INCREMENTAL_PROTECTION_NEEDS + int GC_incremental_protection_needs() + { +@@ -3105,19 +3878,20 @@ + # endif + #endif /* SPARC */ + +-#ifdef SAVE_CALL_CHAIN ++#ifdef NEED_CALLINFO + /* Fill in the pc and argument information for up to NFRAMES of my */ + /* callers. Ignore my frame and my callers frame. */ + + #ifdef LINUX +-# include +-# if __GLIBC__ == 2 && __GLIBC_MINOR__ >= 1 || __GLIBC__ > 2 +-# define HAVE_BUILTIN_BACKTRACE +-# endif ++# include + #endif + ++#endif /* NEED_CALLINFO */ ++ ++#ifdef SAVE_CALL_CHAIN ++ + #if NARGS == 0 && NFRAMES % 2 == 0 /* No padding */ \ +- && defined(HAVE_BUILTIN_BACKTRACE) ++ && defined(GC_HAVE_BUILTIN_BACKTRACE) + + #include + +@@ -3188,31 +3962,139 @@ + + #endif /* SAVE_CALL_CHAIN */ + +-#if defined(LINUX) && defined(__ELF__) && \ +- (!defined(SMALL_CONFIG) || defined(USE_PROC_FOR_LIBRARIES)) +-#ifdef GC_USE_LD_WRAP +-# define READ __real_read +-#else +-# define READ read +-#endif +- ++#ifdef NEED_CALLINFO + +-/* Repeatedly perform a read call until the buffer is filled or */ +-/* we encounter EOF. */ +-ssize_t GC_repeat_read(int fd, char *buf, size_t count) ++/* Print info to stderr. We do NOT hold the allocation lock */ ++void GC_print_callers (info) ++struct callinfo info[NFRAMES]; + { +- ssize_t num_read = 0; +- ssize_t result; ++ register int i; ++ static int reentry_count = 0; ++ GC_bool stop = FALSE; + +- while (num_read < count) { +- result = READ(fd, buf + num_read, count - num_read); +- if (result < 0) return result; +- if (result == 0) break; +- num_read += result; ++ LOCK(); ++ ++reentry_count; ++ UNLOCK(); ++ ++# if NFRAMES == 1 ++ GC_err_printf0("\tCaller at allocation:\n"); ++# else ++ GC_err_printf0("\tCall chain at allocation:\n"); ++# endif ++ for (i = 0; i < NFRAMES && !stop ; i++) { ++ if (info[i].ci_pc == 0) break; ++# if NARGS > 0 ++ { ++ int j; ++ ++ GC_err_printf0("\t\targs: "); ++ for (j = 0; j < NARGS; j++) { ++ if (j != 0) GC_err_printf0(", "); ++ GC_err_printf2("%d (0x%X)", ~(info[i].ci_arg[j]), ++ ~(info[i].ci_arg[j])); + } +- return num_read; ++ GC_err_printf0("\n"); ++ } ++# endif ++ if (reentry_count > 1) { ++ /* We were called during an allocation during */ ++ /* a previous GC_print_callers call; punt. */ ++ GC_err_printf1("\t\t##PC##= 0x%lx\n", info[i].ci_pc); ++ continue; ++ } ++ { ++# ifdef LINUX ++ FILE *pipe; ++# endif ++# if defined(GC_HAVE_BUILTIN_BACKTRACE) ++ char **sym_name = ++ backtrace_symbols((void **)(&(info[i].ci_pc)), 1); ++ char *name = sym_name[0]; ++# else ++ char buf[40]; ++ char *name = buf; ++ sprintf(buf, "##PC##= 0x%lx", info[i].ci_pc); ++# endif ++# if defined(LINUX) && !defined(SMALL_CONFIG) ++ /* Try for a line number. */ ++ { ++# define EXE_SZ 100 ++ static char exe_name[EXE_SZ]; ++# define CMD_SZ 200 ++ char cmd_buf[CMD_SZ]; ++# define RESULT_SZ 200 ++ static char result_buf[RESULT_SZ]; ++ size_t result_len; ++ static GC_bool found_exe_name = FALSE; ++ static GC_bool will_fail = FALSE; ++ int ret_code; ++ /* Try to get it via a hairy and expensive scheme. */ ++ /* First we get the name of the executable: */ ++ if (will_fail) goto out; ++ if (!found_exe_name) { ++ ret_code = readlink("/proc/self/exe", exe_name, EXE_SZ); ++ if (ret_code < 0 || ret_code >= EXE_SZ ++ || exe_name[0] != '/') { ++ will_fail = TRUE; /* Dont try again. */ ++ goto out; ++ } ++ exe_name[ret_code] = '\0'; ++ found_exe_name = TRUE; ++ } ++ /* Then we use popen to start addr2line -e */ ++ /* There are faster ways to do this, but hopefully this */ ++ /* isn't time critical. */ ++ sprintf(cmd_buf, "/usr/bin/addr2line -f -e %s 0x%lx", exe_name, ++ (unsigned long)info[i].ci_pc); ++ pipe = popen(cmd_buf, "r"); ++ if (pipe == NULL ++ || (result_len = fread(result_buf, 1, RESULT_SZ - 1, pipe)) ++ == 0) { ++ if (pipe != NULL) pclose(pipe); ++ will_fail = TRUE; ++ goto out; ++ } ++ if (result_buf[result_len - 1] == '\n') --result_len; ++ result_buf[result_len] = 0; ++ if (result_buf[0] == '?' ++ || result_buf[result_len-2] == ':' ++ && result_buf[result_len-1] == '0') { ++ pclose(pipe); ++ goto out; ++ } ++ /* Get rid of embedded newline, if any. Test for "main" */ ++ { ++ char * nl = strchr(result_buf, '\n'); ++ if (nl != NULL && nl < result_buf + result_len) { ++ *nl = ':'; ++ } ++ if (strncmp(result_buf, "main", nl - result_buf) == 0) { ++ stop = TRUE; ++ } ++ } ++ if (result_len < RESULT_SZ - 25) { ++ /* Add in hex address */ ++ sprintf(result_buf + result_len, " [0x%lx]", ++ (unsigned long)info[i].ci_pc); ++ } ++ name = result_buf; ++ pclose(pipe); ++ out:; ++ } ++# endif /* LINUX */ ++ GC_err_printf1("\t\t%s\n", name); ++# if defined(GC_HAVE_BUILTIN_BACKTRACE) ++ free(sym_name); /* May call GC_free; that's OK */ ++# endif ++ } ++ } ++ LOCK(); ++ --reentry_count; ++ UNLOCK(); + } +-#endif /* LINUX && ... */ ++ ++#endif /* NEED_CALLINFO */ ++ + + + #if defined(LINUX) && defined(__ELF__) && !defined(SMALL_CONFIG) +@@ -3220,20 +4102,16 @@ + /* Dump /proc/self/maps to GC_stderr, to enable looking up names for + addresses in FIND_LEAK output. */ + ++static word dump_maps(char *maps) ++{ ++ GC_err_write(maps, strlen(maps)); ++ return 1; ++} ++ + void GC_print_address_map() + { +- int f; +- int result; +- char maps_temp[32768]; + GC_err_printf0("---------- Begin address map ----------\n"); +- f = open("/proc/self/maps", O_RDONLY); +- if (-1 == f) ABORT("Couldn't open /proc/self/maps"); +- do { +- result = GC_repeat_read(f, maps_temp, sizeof(maps_temp)); +- if (result <= 0) ABORT("Couldn't read /proc/self/maps"); +- GC_err_write(maps_temp, result); +- } while (result == sizeof(maps_temp)); +- ++ GC_apply_to_maps(dump_maps); + GC_err_printf0("---------- End address map ----------\n"); + } + +diff -urNb boehm-gc/powerpc_darwin_mach_dep.s boehm-gc/powerpc_darwin_mach_dep.s +--- boehm-gc/powerpc_darwin_mach_dep.s Wed Dec 31 16:00:00 1969 ++++ boehm-gc/powerpc_darwin_mach_dep.s Mon May 26 12:48:52 2003 +@@ -0,0 +1,84 @@ ++ ++; GC_push_regs function. Under some optimization levels GCC will clobber ++; some of the non-volatile registers before we get a chance to save them ++; therefore, this can't be inline asm. ++ ++.text ++ .align 2 ++ .globl _GC_push_regs ++_GC_push_regs: ++ ++ ; Prolog ++ mflr r0 ++ stw r0,8(r1) ++ stwu r1,-80(r1) ++ ++ ; Push r13-r31 ++ mr r3,r13 ++ bl L_GC_push_one$stub ++ mr r3,r14 ++ bl L_GC_push_one$stub ++ mr r3,r15 ++ bl L_GC_push_one$stub ++ mr r3,r16 ++ bl L_GC_push_one$stub ++ mr r3,r17 ++ bl L_GC_push_one$stub ++ mr r3,r18 ++ bl L_GC_push_one$stub ++ mr r3,r19 ++ bl L_GC_push_one$stub ++ mr r3,r20 ++ bl L_GC_push_one$stub ++ mr r3,r21 ++ bl L_GC_push_one$stub ++ mr r3,r22 ++ bl L_GC_push_one$stub ++ mr r3,r23 ++ bl L_GC_push_one$stub ++ mr r3,r24 ++ bl L_GC_push_one$stub ++ mr r3,r25 ++ bl L_GC_push_one$stub ++ mr r3,r26 ++ bl L_GC_push_one$stub ++ mr r3,r27 ++ bl L_GC_push_one$stub ++ mr r3,r28 ++ bl L_GC_push_one$stub ++ mr r3,r29 ++ bl L_GC_push_one$stub ++ mr r3,r30 ++ bl L_GC_push_one$stub ++ mr r3,r31 ++ bl L_GC_push_one$stub ++ ++ ; ++ lwz r0,88(r1) ++ addi r1,r1,80 ++ mtlr r0 ++ ++ ; Return ++ blr ++ ++; PIC stuff, generated by GCC ++ ++.data ++.picsymbol_stub ++L_GC_push_one$stub: ++ .indirect_symbol _GC_push_one ++ mflr r0 ++ bcl 20,31,L0$_GC_push_one ++L0$_GC_push_one: ++ mflr r11 ++ addis r11,r11,ha16(L_GC_push_one$lazy_ptr-L0$_GC_push_one) ++ mtlr r0 ++ lwz r12,lo16(L_GC_push_one$lazy_ptr-L0$_GC_push_one)(r11) ++ mtctr r12 ++ addi r11,r11,lo16(L_GC_push_one$lazy_ptr-L0$_GC_push_one) ++ bctr ++.data ++.lazy_symbol_pointer ++L_GC_push_one$lazy_ptr: ++ .indirect_symbol _GC_push_one ++ .long dyld_stub_binding_helper +diff -urNb boehm-gc/pthread_stop_world.c boehm-gc/pthread_stop_world.c +--- boehm-gc/pthread_stop_world.c Wed Dec 31 16:00:00 1969 ++++ boehm-gc/pthread_stop_world.c Mon May 26 12:48:52 2003 +@@ -0,0 +1,445 @@ ++#include "private/pthread_support.h" ++ ++#if defined(GC_PTHREADS) && !defined(GC_SOLARIS_THREADS) \ ++ && !defined(GC_IRIX_THREADS) && !defined(GC_WIN32_THREADS) \ ++ && !defined(GC_DARWIN_THREADS) ++ ++#include ++#include ++#include ++#include ++ ++#if DEBUG_THREADS ++ ++#ifndef NSIG ++# if defined(MAXSIG) ++# define NSIG (MAXSIG+1) ++# elif defined(_NSIG) ++# define NSIG _NSIG ++# elif defined(__SIGRTMAX) ++# define NSIG (__SIGRTMAX+1) ++# else ++ --> please fix it ++# endif ++#endif ++ ++void GC_print_sig_mask() ++{ ++ sigset_t blocked; ++ int i; ++ ++ if (pthread_sigmask(SIG_BLOCK, NULL, &blocked) != 0) ++ ABORT("pthread_sigmask"); ++ GC_printf0("Blocked: "); ++ for (i = 1; i < NSIG; i++) { ++ if (sigismember(&blocked, i)) { GC_printf1("%ld ",(long) i); } ++ } ++ GC_printf0("\n"); ++} ++ ++#endif ++ ++word GC_stop_count; /* Incremented at the beginning of GC_stop_world. */ ++ ++#ifdef GC_OSF1_THREADS ++ GC_bool GC_retry_signals = TRUE; ++#else ++ GC_bool GC_retry_signals = FALSE; ++#endif ++ ++/* ++ * We use signals to stop threads during GC. ++ * ++ * Suspended threads wait in signal handler for SIG_THR_RESTART. ++ * That's more portable than semaphores or condition variables. ++ * (We do use sem_post from a signal handler, but that should be portable.) ++ * ++ * The thread suspension signal SIG_SUSPEND is now defined in gc_priv.h. ++ * Note that we can't just stop a thread; we need it to save its stack ++ * pointer(s) and acknowledge. ++ */ ++ ++#ifndef SIG_THR_RESTART ++# if defined(GC_HPUX_THREADS) || defined(GC_OSF1_THREADS) ++# ifdef _SIGRTMIN ++# define SIG_THR_RESTART _SIGRTMIN + 5 ++# else ++# define SIG_THR_RESTART SIGRTMIN + 5 ++# endif ++# else ++# define SIG_THR_RESTART SIGXCPU ++# endif ++#endif ++ ++sem_t GC_suspend_ack_sem; ++ ++void GC_suspend_handler(int sig) ++{ ++ int dummy; ++ pthread_t my_thread = pthread_self(); ++ GC_thread me; ++ sigset_t mask; ++# ifdef PARALLEL_MARK ++ word my_mark_no = GC_mark_no; ++ /* Marker can't proceed until we acknowledge. Thus this is */ ++ /* guaranteed to be the mark_no correspending to our */ ++ /* suspension, i.e. the marker can't have incremented it yet. */ ++# endif ++ word my_stop_count = GC_stop_count; ++ ++ if (sig != SIG_SUSPEND) ABORT("Bad signal in suspend_handler"); ++ ++#if DEBUG_THREADS ++ GC_printf1("Suspending 0x%lx\n", my_thread); ++#endif ++ ++ me = GC_lookup_thread(my_thread); ++ /* The lookup here is safe, since I'm doing this on behalf */ ++ /* of a thread which holds the allocation lock in order */ ++ /* to stop the world. Thus concurrent modification of the */ ++ /* data structure is impossible. */ ++ if (me -> stop_info.last_stop_count == my_stop_count) { ++ /* Duplicate signal. OK if we are retrying. */ ++ if (!GC_retry_signals) { ++ WARN("Duplicate suspend signal in thread %lx\n", ++ pthread_self()); ++ } ++ return; ++ } ++# ifdef SPARC ++ me -> stop_info.stack_ptr = (ptr_t)GC_save_regs_in_stack(); ++# else ++ me -> stop_info.stack_ptr = (ptr_t)(&dummy); ++# endif ++# ifdef IA64 ++ me -> backing_store_ptr = (ptr_t)GC_save_regs_in_stack(); ++# endif ++ ++ /* Tell the thread that wants to stop the world that this */ ++ /* thread has been stopped. Note that sem_post() is */ ++ /* the only async-signal-safe primitive in LinuxThreads. */ ++ sem_post(&GC_suspend_ack_sem); ++ me -> stop_info.last_stop_count = my_stop_count; ++ ++ /* Wait until that thread tells us to restart by sending */ ++ /* this thread a SIG_THR_RESTART signal. */ ++ /* SIG_THR_RESTART should be masked at this point. Thus there */ ++ /* is no race. */ ++ if (sigfillset(&mask) != 0) ABORT("sigfillset() failed"); ++ if (sigdelset(&mask, SIG_THR_RESTART) != 0) ABORT("sigdelset() failed"); ++# ifdef NO_SIGNALS ++ if (sigdelset(&mask, SIGINT) != 0) ABORT("sigdelset() failed"); ++ if (sigdelset(&mask, SIGQUIT) != 0) ABORT("sigdelset() failed"); ++ if (sigdelset(&mask, SIGTERM) != 0) ABORT("sigdelset() failed"); ++ if (sigdelset(&mask, SIGABRT) != 0) ABORT("sigdelset() failed"); ++# endif ++ do { ++ me->stop_info.signal = 0; ++ sigsuspend(&mask); /* Wait for signal */ ++ } while (me->stop_info.signal != SIG_THR_RESTART); ++ /* If the RESTART signal gets lost, we can still lose. That should be */ ++ /* less likely than losing the SUSPEND signal, since we don't do much */ ++ /* between the sem_post and sigsuspend. */ ++ /* We'd need more handshaking to work around that, since we don't want */ ++ /* to accidentally leave a RESTART signal pending, thus causing us to */ ++ /* continue prematurely in a future round. */ ++ ++#if DEBUG_THREADS ++ GC_printf1("Continuing 0x%lx\n", my_thread); ++#endif ++} ++ ++void GC_restart_handler(int sig) ++{ ++ pthread_t my_thread = pthread_self(); ++ GC_thread me; ++ ++ if (sig != SIG_THR_RESTART) ABORT("Bad signal in suspend_handler"); ++ ++ /* Let the GC_suspend_handler() know that we got a SIG_THR_RESTART. */ ++ /* The lookup here is safe, since I'm doing this on behalf */ ++ /* of a thread which holds the allocation lock in order */ ++ /* to stop the world. Thus concurrent modification of the */ ++ /* data structure is impossible. */ ++ me = GC_lookup_thread(my_thread); ++ me->stop_info.signal = SIG_THR_RESTART; ++ ++ /* ++ ** Note: even if we didn't do anything useful here, ++ ** it would still be necessary to have a signal handler, ++ ** rather than ignoring the signals, otherwise ++ ** the signals will not be delivered at all, and ++ ** will thus not interrupt the sigsuspend() above. ++ */ ++ ++#if DEBUG_THREADS ++ GC_printf1("In GC_restart_handler for 0x%lx\n", pthread_self()); ++#endif ++} ++ ++# ifdef IA64 ++# define IF_IA64(x) x ++# else ++# define IF_IA64(x) ++# endif ++/* We hold allocation lock. Should do exactly the right thing if the */ ++/* world is stopped. Should not fail if it isn't. */ ++void GC_push_all_stacks() ++{ ++ int i; ++ GC_thread p; ++ ptr_t lo, hi; ++ /* On IA64, we also need to scan the register backing store. */ ++ IF_IA64(ptr_t bs_lo; ptr_t bs_hi;) ++ pthread_t me = pthread_self(); ++ ++ if (!GC_thr_initialized) GC_thr_init(); ++ #if DEBUG_THREADS ++ GC_printf1("Pushing stacks from thread 0x%lx\n", (unsigned long) me); ++ #endif ++ for (i = 0; i < THREAD_TABLE_SZ; i++) { ++ for (p = GC_threads[i]; p != 0; p = p -> next) { ++ if (p -> flags & FINISHED) continue; ++ if (pthread_equal(p -> id, me)) { ++# ifdef SPARC ++ lo = (ptr_t)GC_save_regs_in_stack(); ++# else ++ lo = GC_approx_sp(); ++# endif ++ IF_IA64(bs_hi = (ptr_t)GC_save_regs_in_stack();) ++ } else { ++ lo = p -> stop_info.stack_ptr; ++ IF_IA64(bs_hi = p -> backing_store_ptr;) ++ } ++ if ((p -> flags & MAIN_THREAD) == 0) { ++ hi = p -> stack_end; ++ IF_IA64(bs_lo = p -> backing_store_end); ++ } else { ++ /* The original stack. */ ++ hi = GC_stackbottom; ++ IF_IA64(bs_lo = BACKING_STORE_BASE;) ++ } ++ #if DEBUG_THREADS ++ GC_printf3("Stack for thread 0x%lx = [%lx,%lx)\n", ++ (unsigned long) p -> id, ++ (unsigned long) lo, (unsigned long) hi); ++ #endif ++ if (0 == lo) ABORT("GC_push_all_stacks: sp not set!\n"); ++# ifdef STACK_GROWS_UP ++ /* We got them backwards! */ ++ GC_push_all_stack(hi, lo); ++# else ++ GC_push_all_stack(lo, hi); ++# endif ++# ifdef IA64 ++ if (pthread_equal(p -> id, me)) { ++ GC_push_all_eager(bs_lo, bs_hi); ++ } else { ++ GC_push_all_stack(bs_lo, bs_hi); ++ } ++# endif ++ } ++ } ++} ++ ++/* There seems to be a very rare thread stopping problem. To help us */ ++/* debug that, we save the ids of the stopping thread. */ ++pthread_t GC_stopping_thread; ++int GC_stopping_pid; ++ ++/* We hold the allocation lock. Suspend all threads that might */ ++/* still be running. Return the number of suspend signals that */ ++/* were sent. */ ++int GC_suspend_all() ++{ ++ int n_live_threads = 0; ++ int i; ++ GC_thread p; ++ int result; ++ pthread_t my_thread = pthread_self(); ++ ++ GC_stopping_thread = my_thread; /* debugging only. */ ++ GC_stopping_pid = getpid(); /* debugging only. */ ++ for (i = 0; i < THREAD_TABLE_SZ; i++) { ++ for (p = GC_threads[i]; p != 0; p = p -> next) { ++ if (p -> id != my_thread) { ++ if (p -> flags & FINISHED) continue; ++ if (p -> stop_info.last_stop_count == GC_stop_count) continue; ++ if (p -> thread_blocked) /* Will wait */ continue; ++ n_live_threads++; ++ #if DEBUG_THREADS ++ GC_printf1("Sending suspend signal to 0x%lx\n", p -> id); ++ #endif ++ ++ result = pthread_kill(p -> id, SIG_SUSPEND); ++ switch(result) { ++ case ESRCH: ++ /* Not really there anymore. Possible? */ ++ n_live_threads--; ++ break; ++ case 0: ++ break; ++ default: ++ ABORT("pthread_kill failed"); ++ } ++ } ++ } ++ } ++ return n_live_threads; ++} ++ ++/* Caller holds allocation lock. */ ++void GC_stop_world() ++{ ++ int i; ++ int n_live_threads; ++ int code; ++ ++ #if DEBUG_THREADS ++ GC_printf1("Stopping the world from 0x%lx\n", pthread_self()); ++ #endif ++ ++ /* Make sure all free list construction has stopped before we start. */ ++ /* No new construction can start, since free list construction is */ ++ /* required to acquire and release the GC lock before it starts, */ ++ /* and we have the lock. */ ++# ifdef PARALLEL_MARK ++ GC_acquire_mark_lock(); ++ GC_ASSERT(GC_fl_builder_count == 0); ++ /* We should have previously waited for it to become zero. */ ++# endif /* PARALLEL_MARK */ ++ ++GC_stop_count; ++ n_live_threads = GC_suspend_all(); ++ ++ if (GC_retry_signals) { ++ unsigned long wait_usecs = 0; /* Total wait since retry. */ ++# define WAIT_UNIT 3000 ++# define RETRY_INTERVAL 100000 ++ for (;;) { ++ int ack_count; ++ ++ sem_getvalue(&GC_suspend_ack_sem, &ack_count); ++ if (ack_count == n_live_threads) break; ++ if (wait_usecs > RETRY_INTERVAL) { ++ int newly_sent = GC_suspend_all(); ++ ++# ifdef CONDPRINT ++ if (GC_print_stats) { ++ GC_printf1("Resent %ld signals after timeout\n", ++ newly_sent); ++ } ++# endif ++ sem_getvalue(&GC_suspend_ack_sem, &ack_count); ++ if (newly_sent < n_live_threads - ack_count) { ++ WARN("Lost some threads during GC_stop_world?!\n",0); ++ n_live_threads = ack_count + newly_sent; ++ } ++ wait_usecs = 0; ++ } ++ usleep(WAIT_UNIT); ++ wait_usecs += WAIT_UNIT; ++ } ++ } ++ for (i = 0; i < n_live_threads; i++) { ++ if (0 != (code = sem_wait(&GC_suspend_ack_sem))) { ++ GC_err_printf1("Sem_wait returned %ld\n", (unsigned long)code); ++ ABORT("sem_wait for handler failed"); ++ } ++ } ++# ifdef PARALLEL_MARK ++ GC_release_mark_lock(); ++# endif ++ #if DEBUG_THREADS ++ GC_printf1("World stopped from 0x%lx\n", pthread_self()); ++ #endif ++ GC_stopping_thread = 0; /* debugging only */ ++} ++ ++/* Caller holds allocation lock, and has held it continuously since */ ++/* the world stopped. */ ++void GC_start_world() ++{ ++ pthread_t my_thread = pthread_self(); ++ register int i; ++ register GC_thread p; ++ register int n_live_threads = 0; ++ register int result; ++ ++# if DEBUG_THREADS ++ GC_printf0("World starting\n"); ++# endif ++ ++ for (i = 0; i < THREAD_TABLE_SZ; i++) { ++ for (p = GC_threads[i]; p != 0; p = p -> next) { ++ if (p -> id != my_thread) { ++ if (p -> flags & FINISHED) continue; ++ if (p -> thread_blocked) continue; ++ n_live_threads++; ++ #if DEBUG_THREADS ++ GC_printf1("Sending restart signal to 0x%lx\n", p -> id); ++ #endif ++ ++ result = pthread_kill(p -> id, SIG_THR_RESTART); ++ switch(result) { ++ case ESRCH: ++ /* Not really there anymore. Possible? */ ++ n_live_threads--; ++ break; ++ case 0: ++ break; ++ default: ++ ABORT("pthread_kill failed"); ++ } ++ } ++ } ++ } ++ #if DEBUG_THREADS ++ GC_printf0("World started\n"); ++ #endif ++} ++ ++void GC_stop_init() { ++ struct sigaction act; ++ ++ if (sem_init(&GC_suspend_ack_sem, 0, 0) != 0) ++ ABORT("sem_init failed"); ++ ++ act.sa_flags = SA_RESTART; ++ if (sigfillset(&act.sa_mask) != 0) { ++ ABORT("sigfillset() failed"); ++ } ++# ifdef NO_SIGNALS ++ if (sigdelset(&act.sa_mask, SIGINT) != 0 ++ || sigdelset(&act.sa_mask, SIGQUIT != 0) ++ || sigdelset(&act.sa_mask, SIGABRT != 0) ++ || sigdelset(&act.sa_mask, SIGTERM != 0)) { ++ ABORT("sigdelset() failed"); ++ } ++# endif ++ ++ /* SIG_THR_RESTART is unmasked by the handler when necessary. */ ++ act.sa_handler = GC_suspend_handler; ++ if (sigaction(SIG_SUSPEND, &act, NULL) != 0) { ++ ABORT("Cannot set SIG_SUSPEND handler"); ++ } ++ ++ act.sa_handler = GC_restart_handler; ++ if (sigaction(SIG_THR_RESTART, &act, NULL) != 0) { ++ ABORT("Cannot set SIG_THR_RESTART handler"); ++ } ++ ++ /* Check for GC_RETRY_SIGNALS. */ ++ if (0 != GETENV("GC_RETRY_SIGNALS")) { ++ GC_retry_signals = TRUE; ++ } ++ if (0 != GETENV("GC_NO_RETRY_SIGNALS")) { ++ GC_retry_signals = FALSE; ++ } ++# ifdef CONDPRINT ++ if (GC_print_stats && GC_retry_signals) { ++ GC_printf0("Will retry suspend signal if necessary.\n"); ++ } ++# endif ++} ++ ++#endif +diff -urNb boehm-gc/pthread_support.c boehm-gc/pthread_support.c +--- boehm-gc/pthread_support.c Wed Dec 31 16:00:00 1969 ++++ boehm-gc/pthread_support.c Mon May 26 12:48:52 2003 +@@ -0,0 +1,1568 @@ ++/* ++ * Copyright (c) 1994 by Xerox Corporation. All rights reserved. ++ * Copyright (c) 1996 by Silicon Graphics. All rights reserved. ++ * Copyright (c) 1998 by Fergus Henderson. All rights reserved. ++ * Copyright (c) 2000-2001 by Hewlett-Packard Company. All rights reserved. ++ * ++ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED ++ * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. ++ * ++ * Permission is hereby granted to use or copy this program ++ * for any purpose, provided the above notices are retained on all copies. ++ * Permission to modify the code and to distribute modified code is granted, ++ * provided the above notices are retained, and a notice that the code was ++ * modified is included with the above copyright notice. ++ */ ++/* ++ * Support code for LinuxThreads, the clone()-based kernel ++ * thread package for Linux which is included in libc6. ++ * ++ * This code relies on implementation details of LinuxThreads, ++ * (i.e. properties not guaranteed by the Pthread standard), ++ * though this version now does less of that than the other Pthreads ++ * support code. ++ * ++ * Note that there is a lot of code duplication between linux_threads.c ++ * and thread support for some of the other Posix platforms; any changes ++ * made here may need to be reflected there too. ++ */ ++ /* DG/UX ix86 support */ ++/* ++ * Linux_threads.c now also includes some code to support HPUX and ++ * OSF1 (Compaq Tru64 Unix, really). The OSF1 support is not yet ++ * functional. The OSF1 code is based on Eric Benson's ++ * patch, though that was originally against hpux_irix_threads. The code ++ * here is completely untested. With 0.0000001% probability, it might ++ * actually work. ++ * ++ * Eric also suggested an alternate basis for a lock implementation in ++ * his code: ++ * + #elif defined(OSF1) ++ * + unsigned long GC_allocate_lock = 0; ++ * + msemaphore GC_allocate_semaphore; ++ * + # define GC_TRY_LOCK() \ ++ * + ((msem_lock(&GC_allocate_semaphore, MSEM_IF_NOWAIT) == 0) \ ++ * + ? (GC_allocate_lock = 1) \ ++ * + : 0) ++ * + # define GC_LOCK_TAKEN GC_allocate_lock ++ */ ++ ++/*#define DEBUG_THREADS 1*/ ++/*#define GC_ASSERTIONS*/ ++ ++# include "private/pthread_support.h" ++ ++# if defined(GC_PTHREADS) && !defined(GC_SOLARIS_THREADS) \ ++ && !defined(GC_IRIX_THREADS) && !defined(GC_WIN32_THREADS) ++ ++# if defined(GC_HPUX_THREADS) && !defined(USE_PTHREAD_SPECIFIC) \ ++ && !defined(USE_HPUX_TLS) ++# define USE_HPUX_TLS ++# endif ++ ++# if (defined(GC_DGUX386_THREADS) || defined(GC_OSF1_THREADS) || \ ++ defined(GC_DARWIN_THREADS)) && !defined(USE_PTHREAD_SPECIFIC) ++# define USE_PTHREAD_SPECIFIC ++# endif ++ ++# if defined(GC_DGUX386_THREADS) && !defined(_POSIX4A_DRAFT10_SOURCE) ++# define _POSIX4A_DRAFT10_SOURCE 1 ++# endif ++ ++# if defined(GC_DGUX386_THREADS) && !defined(_USING_POSIX4A_DRAFT10) ++# define _USING_POSIX4A_DRAFT10 1 ++# endif ++ ++# ifdef THREAD_LOCAL_ALLOC ++# if !defined(USE_PTHREAD_SPECIFIC) && !defined(USE_HPUX_TLS) ++# include "private/specific.h" ++# endif ++# if defined(USE_PTHREAD_SPECIFIC) ++# define GC_getspecific pthread_getspecific ++# define GC_setspecific pthread_setspecific ++# define GC_key_create pthread_key_create ++ typedef pthread_key_t GC_key_t; ++# endif ++# if defined(USE_HPUX_TLS) ++# define GC_getspecific(x) (x) ++# define GC_setspecific(key, v) ((key) = (v), 0) ++# define GC_key_create(key, d) 0 ++ typedef void * GC_key_t; ++# endif ++# endif ++# include ++# include ++# include ++# include ++# include ++# include ++# include ++# include ++# include ++# include ++# include ++ ++#if defined(GC_DARWIN_THREADS) ++# include "private/darwin_semaphore.h" ++#else ++# include ++#endif /* !GC_DARWIN_THREADS */ ++ ++#if defined(GC_DARWIN_THREADS) ++# include ++#endif /* GC_DARWIN_THREADS */ ++ ++ ++ ++#if defined(GC_DGUX386_THREADS) ++# include ++# include ++ /* sem_t is an uint in DG/UX */ ++ typedef unsigned int sem_t; ++#endif /* GC_DGUX386_THREADS */ ++ ++#ifndef __GNUC__ ++# define __inline__ ++#endif ++ ++#ifdef GC_USE_LD_WRAP ++# define WRAP_FUNC(f) __wrap_##f ++# define REAL_FUNC(f) __real_##f ++#else ++# define WRAP_FUNC(f) GC_##f ++# if !defined(GC_DGUX386_THREADS) ++# define REAL_FUNC(f) f ++# else /* GC_DGUX386_THREADS */ ++# define REAL_FUNC(f) __d10_##f ++# endif /* GC_DGUX386_THREADS */ ++# undef pthread_create ++# if !defined(GC_DARWIN_THREADS) ++# undef pthread_sigmask ++# endif ++# undef pthread_join ++# undef pthread_detach ++#endif ++ ++void GC_thr_init(); ++ ++static GC_bool parallel_initialized = FALSE; ++ ++void GC_init_parallel(); ++ ++# if defined(THREAD_LOCAL_ALLOC) && !defined(DBG_HDRS_ALL) ++ ++/* We don't really support thread-local allocation with DBG_HDRS_ALL */ ++ ++#ifdef USE_HPUX_TLS ++ __thread ++#endif ++GC_key_t GC_thread_key; ++ ++static GC_bool keys_initialized; ++ ++/* Recover the contents of the freelist array fl into the global one gfl.*/ ++/* Note that the indexing scheme differs, in that gfl has finer size */ ++/* resolution, even if not all entries are used. */ ++/* We hold the allocator lock. */ ++static void return_freelists(ptr_t *fl, ptr_t *gfl) ++{ ++ int i; ++ ptr_t q, *qptr; ++ size_t nwords; ++ ++ for (i = 1; i < NFREELISTS; ++i) { ++ nwords = i * (GRANULARITY/sizeof(word)); ++ qptr = fl + i; ++ q = *qptr; ++ if ((word)q >= HBLKSIZE) { ++ if (gfl[nwords] == 0) { ++ gfl[nwords] = q; ++ } else { ++ /* Concatenate: */ ++ for (; (word)q >= HBLKSIZE; qptr = &(obj_link(q)), q = *qptr); ++ GC_ASSERT(0 == q); ++ *qptr = gfl[nwords]; ++ gfl[nwords] = fl[i]; ++ } ++ } ++ /* Clear fl[i], since the thread structure may hang around. */ ++ /* Do it in a way that is likely to trap if we access it. */ ++ fl[i] = (ptr_t)HBLKSIZE; ++ } ++} ++ ++/* We statically allocate a single "size 0" object. It is linked to */ ++/* itself, and is thus repeatedly reused for all size 0 allocation */ ++/* requests. (Size 0 gcj allocation requests are incorrect, and */ ++/* we arrange for those to fault asap.) */ ++static ptr_t size_zero_object = (ptr_t)(&size_zero_object); ++ ++/* Each thread structure must be initialized. */ ++/* This call must be made from the new thread. */ ++/* Caller holds allocation lock. */ ++void GC_init_thread_local(GC_thread p) ++{ ++ int i; ++ ++ if (!keys_initialized) { ++ if (0 != GC_key_create(&GC_thread_key, 0)) { ++ ABORT("Failed to create key for local allocator"); ++ } ++ keys_initialized = TRUE; ++ } ++ if (0 != GC_setspecific(GC_thread_key, p)) { ++ ABORT("Failed to set thread specific allocation pointers"); ++ } ++ for (i = 1; i < NFREELISTS; ++i) { ++ p -> ptrfree_freelists[i] = (ptr_t)1; ++ p -> normal_freelists[i] = (ptr_t)1; ++# ifdef GC_GCJ_SUPPORT ++ p -> gcj_freelists[i] = (ptr_t)1; ++# endif ++ } ++ /* Set up the size 0 free lists. */ ++ p -> ptrfree_freelists[0] = (ptr_t)(&size_zero_object); ++ p -> normal_freelists[0] = (ptr_t)(&size_zero_object); ++# ifdef GC_GCJ_SUPPORT ++ p -> gcj_freelists[0] = (ptr_t)(-1); ++# endif ++} ++ ++#ifdef GC_GCJ_SUPPORT ++ extern ptr_t * GC_gcjobjfreelist; ++#endif ++ ++/* We hold the allocator lock. */ ++void GC_destroy_thread_local(GC_thread p) ++{ ++ /* We currently only do this from the thread itself or from */ ++ /* the fork handler for a child process. */ ++# ifndef HANDLE_FORK ++ GC_ASSERT(GC_getspecific(GC_thread_key) == (void *)p); ++# endif ++ return_freelists(p -> ptrfree_freelists, GC_aobjfreelist); ++ return_freelists(p -> normal_freelists, GC_objfreelist); ++# ifdef GC_GCJ_SUPPORT ++ return_freelists(p -> gcj_freelists, GC_gcjobjfreelist); ++# endif ++} ++ ++extern GC_PTR GC_generic_malloc_many(); ++ ++GC_PTR GC_local_malloc(size_t bytes) ++{ ++ if (EXPECT(!SMALL_ENOUGH(bytes),0)) { ++ return(GC_malloc(bytes)); ++ } else { ++ int index = INDEX_FROM_BYTES(bytes); ++ ptr_t * my_fl; ++ ptr_t my_entry; ++# if defined(REDIRECT_MALLOC) && !defined(USE_PTHREAD_SPECIFIC) ++ GC_key_t k = GC_thread_key; ++# endif ++ void * tsd; ++ ++# if defined(REDIRECT_MALLOC) && !defined(USE_PTHREAD_SPECIFIC) ++ if (EXPECT(0 == k, 0)) { ++ /* This can happen if we get called when the world is */ ++ /* being initialized. Whether we can actually complete */ ++ /* the initialization then is unclear. */ ++ GC_init_parallel(); ++ k = GC_thread_key; ++ } ++# endif ++ tsd = GC_getspecific(GC_thread_key); ++# ifdef GC_ASSERTIONS ++ LOCK(); ++ GC_ASSERT(tsd == (void *)GC_lookup_thread(pthread_self())); ++ UNLOCK(); ++# endif ++ my_fl = ((GC_thread)tsd) -> normal_freelists + index; ++ my_entry = *my_fl; ++ if (EXPECT((word)my_entry >= HBLKSIZE, 1)) { ++ ptr_t next = obj_link(my_entry); ++ GC_PTR result = (GC_PTR)my_entry; ++ *my_fl = next; ++ obj_link(my_entry) = 0; ++ PREFETCH_FOR_WRITE(next); ++ return result; ++ } else if ((word)my_entry - 1 < DIRECT_GRANULES) { ++ *my_fl = my_entry + index + 1; ++ return GC_malloc(bytes); ++ } else { ++ GC_generic_malloc_many(BYTES_FROM_INDEX(index), NORMAL, my_fl); ++ if (*my_fl == 0) return GC_oom_fn(bytes); ++ return GC_local_malloc(bytes); ++ } ++ } ++} ++ ++GC_PTR GC_local_malloc_atomic(size_t bytes) ++{ ++ if (EXPECT(!SMALL_ENOUGH(bytes), 0)) { ++ return(GC_malloc_atomic(bytes)); ++ } else { ++ int index = INDEX_FROM_BYTES(bytes); ++ ptr_t * my_fl = ((GC_thread)GC_getspecific(GC_thread_key)) ++ -> ptrfree_freelists + index; ++ ptr_t my_entry = *my_fl; ++ ++ if (EXPECT((word)my_entry >= HBLKSIZE, 1)) { ++ GC_PTR result = (GC_PTR)my_entry; ++ *my_fl = obj_link(my_entry); ++ return result; ++ } else if ((word)my_entry - 1 < DIRECT_GRANULES) { ++ *my_fl = my_entry + index + 1; ++ return GC_malloc_atomic(bytes); ++ } else { ++ GC_generic_malloc_many(BYTES_FROM_INDEX(index), PTRFREE, my_fl); ++ /* *my_fl is updated while the collector is excluded; */ ++ /* the free list is always visible to the collector as */ ++ /* such. */ ++ if (*my_fl == 0) return GC_oom_fn(bytes); ++ return GC_local_malloc_atomic(bytes); ++ } ++ } ++} ++ ++#ifdef GC_GCJ_SUPPORT ++ ++#include "include/gc_gcj.h" ++ ++#ifdef GC_ASSERTIONS ++ extern GC_bool GC_gcj_malloc_initialized; ++#endif ++ ++extern int GC_gcj_kind; ++ ++GC_PTR GC_local_gcj_malloc(size_t bytes, ++ void * ptr_to_struct_containing_descr) ++{ ++ GC_ASSERT(GC_gcj_malloc_initialized); ++ if (EXPECT(!SMALL_ENOUGH(bytes), 0)) { ++ return GC_gcj_malloc(bytes, ptr_to_struct_containing_descr); ++ } else { ++ int index = INDEX_FROM_BYTES(bytes); ++ ptr_t * my_fl = ((GC_thread)GC_getspecific(GC_thread_key)) ++ -> gcj_freelists + index; ++ ptr_t my_entry = *my_fl; ++ if (EXPECT((word)my_entry >= HBLKSIZE, 1)) { ++ GC_PTR result = (GC_PTR)my_entry; ++ GC_ASSERT(!GC_incremental); ++ /* We assert that any concurrent marker will stop us. */ ++ /* Thus it is impossible for a mark procedure to see the */ ++ /* allocation of the next object, but to see this object */ ++ /* still containing a free list pointer. Otherwise the */ ++ /* marker might find a random "mark descriptor". */ ++ *(volatile ptr_t *)my_fl = obj_link(my_entry); ++ /* We must update the freelist before we store the pointer. */ ++ /* Otherwise a GC at this point would see a corrupted */ ++ /* free list. */ ++ /* A memory barrier is probably never needed, since the */ ++ /* action of stopping this thread will cause prior writes */ ++ /* to complete. */ ++ GC_ASSERT(((void * volatile *)result)[1] == 0); ++ *(void * volatile *)result = ptr_to_struct_containing_descr; ++ return result; ++ } else if ((word)my_entry - 1 < DIRECT_GRANULES) { ++ if (!GC_incremental) *my_fl = my_entry + index + 1; ++ /* In the incremental case, we always have to take this */ ++ /* path. Thus we leave the counter alone. */ ++ return GC_gcj_malloc(bytes, ptr_to_struct_containing_descr); ++ } else { ++ GC_generic_malloc_many(BYTES_FROM_INDEX(index), GC_gcj_kind, my_fl); ++ if (*my_fl == 0) return GC_oom_fn(bytes); ++ return GC_local_gcj_malloc(bytes, ptr_to_struct_containing_descr); ++ } ++ } ++} ++ ++#endif /* GC_GCJ_SUPPORT */ ++ ++# else /* !THREAD_LOCAL_ALLOC && !DBG_HDRS_ALL */ ++ ++# define GC_destroy_thread_local(t) ++ ++# endif /* !THREAD_LOCAL_ALLOC */ ++ ++#if 0 ++/* ++To make sure that we're using LinuxThreads and not some other thread ++package, we generate a dummy reference to `pthread_kill_other_threads_np' ++(was `__pthread_initial_thread_bos' but that disappeared), ++which is a symbol defined in LinuxThreads, but (hopefully) not in other ++thread packages. ++ ++We no longer do this, since this code is now portable enough that it might ++actually work for something else. ++*/ ++void (*dummy_var_to_force_linux_threads)() = pthread_kill_other_threads_np; ++#endif /* 0 */ ++ ++#if defined(SPARC) || defined(IA64) ++ extern word GC_save_regs_in_stack(); ++#endif ++ ++long GC_nprocs = 1; /* Number of processors. We may not have */ ++ /* access to all of them, but this is as good */ ++ /* a guess as any ... */ ++ ++#ifdef PARALLEL_MARK ++ ++# ifndef MAX_MARKERS ++# define MAX_MARKERS 16 ++# endif ++ ++static ptr_t marker_sp[MAX_MARKERS] = {0}; ++ ++void * GC_mark_thread(void * id) ++{ ++ word my_mark_no = 0; ++ ++ marker_sp[(word)id] = GC_approx_sp(); ++ for (;; ++my_mark_no) { ++ /* GC_mark_no is passed only to allow GC_help_marker to terminate */ ++ /* promptly. This is important if it were called from the signal */ ++ /* handler or from the GC lock acquisition code. Under Linux, it's */ ++ /* not safe to call it from a signal handler, since it uses mutexes */ ++ /* and condition variables. Since it is called only here, the */ ++ /* argument is unnecessary. */ ++ if (my_mark_no < GC_mark_no || my_mark_no > GC_mark_no + 2) { ++ /* resynchronize if we get far off, e.g. because GC_mark_no */ ++ /* wrapped. */ ++ my_mark_no = GC_mark_no; ++ } ++# ifdef DEBUG_THREADS ++ GC_printf1("Starting mark helper for mark number %ld\n", my_mark_no); ++# endif ++ GC_help_marker(my_mark_no); ++ } ++} ++ ++extern long GC_markers; /* Number of mark threads we would */ ++ /* like to have. Includes the */ ++ /* initiating thread. */ ++ ++pthread_t GC_mark_threads[MAX_MARKERS]; ++ ++#define PTHREAD_CREATE REAL_FUNC(pthread_create) ++ ++static void start_mark_threads() ++{ ++ unsigned i; ++ pthread_attr_t attr; ++ ++ if (GC_markers > MAX_MARKERS) { ++ WARN("Limiting number of mark threads\n", 0); ++ GC_markers = MAX_MARKERS; ++ } ++ if (0 != pthread_attr_init(&attr)) ABORT("pthread_attr_init failed"); ++ ++ if (0 != pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED)) ++ ABORT("pthread_attr_setdetachstate failed"); ++ ++# if defined(HPUX) || defined(GC_DGUX386_THREADS) ++ /* Default stack size is usually too small: fix it. */ ++ /* Otherwise marker threads or GC may run out of */ ++ /* space. */ ++# define MIN_STACK_SIZE (8*HBLKSIZE*sizeof(word)) ++ { ++ size_t old_size; ++ int code; ++ ++ if (pthread_attr_getstacksize(&attr, &old_size) != 0) ++ ABORT("pthread_attr_getstacksize failed\n"); ++ if (old_size < MIN_STACK_SIZE) { ++ if (pthread_attr_setstacksize(&attr, MIN_STACK_SIZE) != 0) ++ ABORT("pthread_attr_setstacksize failed\n"); ++ } ++ } ++# endif /* HPUX || GC_DGUX386_THREADS */ ++# ifdef CONDPRINT ++ if (GC_print_stats) { ++ GC_printf1("Starting %ld marker threads\n", GC_markers - 1); ++ } ++# endif ++ for (i = 0; i < GC_markers - 1; ++i) { ++ if (0 != PTHREAD_CREATE(GC_mark_threads + i, &attr, ++ GC_mark_thread, (void *)(word)i)) { ++ WARN("Marker thread creation failed, errno = %ld.\n", errno); ++ } ++ } ++} ++ ++#else /* !PARALLEL_MARK */ ++ ++static __inline__ void start_mark_threads() ++{ ++} ++ ++#endif /* !PARALLEL_MARK */ ++ ++/* Defining INSTALL_LOOPING_SEGV_HANDLER causes SIGSEGV and SIGBUS to */ ++/* result in an infinite loop in a signal handler. This can be very */ ++/* useful for debugging, since (as of RH7) gdb still seems to have */ ++/* serious problems with threads. */ ++#ifdef INSTALL_LOOPING_SEGV_HANDLER ++void GC_looping_handler(int sig) ++{ ++ GC_printf3("Signal %ld in thread %lx, pid %ld\n", ++ sig, pthread_self(), getpid()); ++ for (;;); ++} ++#endif ++ ++GC_bool GC_thr_initialized = FALSE; ++ ++volatile GC_thread GC_threads[THREAD_TABLE_SZ]; ++ ++void GC_push_thread_structures GC_PROTO((void)) ++{ ++ GC_push_all((ptr_t)(GC_threads), (ptr_t)(GC_threads)+sizeof(GC_threads)); ++# if defined(THREAD_LOCAL_ALLOC) && !defined(DBG_HDRS_ALL) ++ GC_push_all((ptr_t)(&GC_thread_key), ++ (ptr_t)(&GC_thread_key)+sizeof(&GC_thread_key)); ++# endif ++} ++ ++#ifdef THREAD_LOCAL_ALLOC ++/* We must explicitly mark ptrfree and gcj free lists, since the free */ ++/* list links wouldn't otherwise be found. We also set them in the */ ++/* normal free lists, since that involves touching less memory than if */ ++/* we scanned them normally. */ ++void GC_mark_thread_local_free_lists(void) ++{ ++ int i, j; ++ GC_thread p; ++ ptr_t q; ++ ++ for (i = 0; i < THREAD_TABLE_SZ; ++i) { ++ for (p = GC_threads[i]; 0 != p; p = p -> next) { ++ for (j = 1; j < NFREELISTS; ++j) { ++ q = p -> ptrfree_freelists[j]; ++ if ((word)q > HBLKSIZE) GC_set_fl_marks(q); ++ q = p -> normal_freelists[j]; ++ if ((word)q > HBLKSIZE) GC_set_fl_marks(q); ++# ifdef GC_GCJ_SUPPORT ++ q = p -> gcj_freelists[j]; ++ if ((word)q > HBLKSIZE) GC_set_fl_marks(q); ++# endif /* GC_GCJ_SUPPORT */ ++ } ++ } ++ } ++} ++#endif /* THREAD_LOCAL_ALLOC */ ++ ++static struct GC_Thread_Rep first_thread; ++ ++/* Add a thread to GC_threads. We assume it wasn't already there. */ ++/* Caller holds allocation lock. */ ++GC_thread GC_new_thread(pthread_t id) ++{ ++ int hv = ((word)id) % THREAD_TABLE_SZ; ++ GC_thread result; ++ static GC_bool first_thread_used = FALSE; ++ ++ if (!first_thread_used) { ++ result = &first_thread; ++ first_thread_used = TRUE; ++ } else { ++ result = (struct GC_Thread_Rep *) ++ GC_INTERNAL_MALLOC(sizeof(struct GC_Thread_Rep), NORMAL); ++ } ++ if (result == 0) return(0); ++ result -> id = id; ++ result -> next = GC_threads[hv]; ++ GC_threads[hv] = result; ++ GC_ASSERT(result -> flags == 0 && result -> thread_blocked == 0); ++ return(result); ++} ++ ++/* Delete a thread from GC_threads. We assume it is there. */ ++/* (The code intentionally traps if it wasn't.) */ ++/* Caller holds allocation lock. */ ++void GC_delete_thread(pthread_t id) ++{ ++ int hv = ((word)id) % THREAD_TABLE_SZ; ++ register GC_thread p = GC_threads[hv]; ++ register GC_thread prev = 0; ++ ++ while (!pthread_equal(p -> id, id)) { ++ prev = p; ++ p = p -> next; ++ } ++ if (prev == 0) { ++ GC_threads[hv] = p -> next; ++ } else { ++ prev -> next = p -> next; ++ } ++ GC_INTERNAL_FREE(p); ++} ++ ++/* If a thread has been joined, but we have not yet */ ++/* been notified, then there may be more than one thread */ ++/* in the table with the same pthread id. */ ++/* This is OK, but we need a way to delete a specific one. */ ++void GC_delete_gc_thread(pthread_t id, GC_thread gc_id) ++{ ++ int hv = ((word)id) % THREAD_TABLE_SZ; ++ register GC_thread p = GC_threads[hv]; ++ register GC_thread prev = 0; ++ ++ while (p != gc_id) { ++ prev = p; ++ p = p -> next; ++ } ++ if (prev == 0) { ++ GC_threads[hv] = p -> next; ++ } else { ++ prev -> next = p -> next; ++ } ++ GC_INTERNAL_FREE(p); ++} ++ ++/* Return a GC_thread corresponding to a given thread_t. */ ++/* Returns 0 if it's not there. */ ++/* Caller holds allocation lock or otherwise inhibits */ ++/* updates. */ ++/* If there is more than one thread with the given id we */ ++/* return the most recent one. */ ++GC_thread GC_lookup_thread(pthread_t id) ++{ ++ int hv = ((word)id) % THREAD_TABLE_SZ; ++ register GC_thread p = GC_threads[hv]; ++ ++ while (p != 0 && !pthread_equal(p -> id, id)) p = p -> next; ++ return(p); ++} ++ ++#ifdef HANDLE_FORK ++/* Remove all entries from the GC_threads table, except the */ ++/* one for the current thread. We need to do this in the child */ ++/* process after a fork(), since only the current thread */ ++/* survives in the child. */ ++void GC_remove_all_threads_but_me(void) ++{ ++ pthread_t self = pthread_self(); ++ int hv; ++ GC_thread p, next, me; ++ ++ for (hv = 0; hv < THREAD_TABLE_SZ; ++hv) { ++ me = 0; ++ for (p = GC_threads[hv]; 0 != p; p = next) { ++ next = p -> next; ++ if (p -> id == self) { ++ me = p; ++ p -> next = 0; ++ } else { ++# ifdef THREAD_LOCAL_ALLOC ++ if (!(p -> flags & FINISHED)) { ++ GC_destroy_thread_local(p); ++ } ++# endif /* THREAD_LOCAL_ALLOC */ ++ if (p != &first_thread) GC_INTERNAL_FREE(p); ++ } ++ } ++ GC_threads[hv] = me; ++ } ++} ++#endif /* HANDLE_FORK */ ++ ++#ifdef USE_PROC_FOR_LIBRARIES ++int GC_segment_is_thread_stack(ptr_t lo, ptr_t hi) ++{ ++ int i; ++ GC_thread p; ++ ++# ifdef PARALLEL_MARK ++ for (i = 0; i < GC_markers; ++i) { ++ if (marker_sp[i] > lo & marker_sp[i] < hi) return 1; ++ } ++# endif ++ for (i = 0; i < THREAD_TABLE_SZ; i++) { ++ for (p = GC_threads[i]; p != 0; p = p -> next) { ++ if (0 != p -> stack_end) { ++# ifdef STACK_GROWS_UP ++ if (p -> stack_end >= lo && p -> stack_end < hi) return 1; ++# else /* STACK_GROWS_DOWN */ ++ if (p -> stack_end > lo && p -> stack_end <= hi) return 1; ++# endif ++ } ++ } ++ } ++ return 0; ++} ++#endif /* USE_PROC_FOR_LIBRARIES */ ++ ++#ifdef GC_LINUX_THREADS ++/* Return the number of processors, or i<= 0 if it can't be determined. */ ++int GC_get_nprocs() ++{ ++ /* Should be "return sysconf(_SC_NPROCESSORS_ONLN);" but that */ ++ /* appears to be buggy in many cases. */ ++ /* We look for lines "cpu" in /proc/stat. */ ++# define STAT_BUF_SIZE 4096 ++# define STAT_READ read ++ /* If read is wrapped, this may need to be redefined to call */ ++ /* the real one. */ ++ char stat_buf[STAT_BUF_SIZE]; ++ int f; ++ word result = 1; ++ /* Some old kernels only have a single "cpu nnnn ..." */ ++ /* entry in /proc/stat. We identify those as */ ++ /* uniprocessors. */ ++ size_t i, len = 0; ++ ++ f = open("/proc/stat", O_RDONLY); ++ if (f < 0 || (len = STAT_READ(f, stat_buf, STAT_BUF_SIZE)) < 100) { ++ WARN("Couldn't read /proc/stat\n", 0); ++ return -1; ++ } ++ for (i = 0; i < len - 100; ++i) { ++ if (stat_buf[i] == '\n' && stat_buf[i+1] == 'c' ++ && stat_buf[i+2] == 'p' && stat_buf[i+3] == 'u') { ++ int cpu_no = atoi(stat_buf + i + 4); ++ if (cpu_no >= result) result = cpu_no + 1; ++ } ++ } ++ close(f); ++ return result; ++} ++#endif /* GC_LINUX_THREADS */ ++ ++/* We hold the GC lock. Wait until an in-progress GC has finished. */ ++/* Repeatedly RELEASES GC LOCK in order to wait. */ ++/* If wait_for_all is true, then we exit with the GC lock held and no */ ++/* collection in progress; otherwise we just wait for the current GC */ ++/* to finish. */ ++extern GC_bool GC_collection_in_progress(); ++void GC_wait_for_gc_completion(GC_bool wait_for_all) ++{ ++ if (GC_incremental && GC_collection_in_progress()) { ++ int old_gc_no = GC_gc_no; ++ ++ /* Make sure that no part of our stack is still on the mark stack, */ ++ /* since it's about to be unmapped. */ ++ while (GC_incremental && GC_collection_in_progress() ++ && (wait_for_all || old_gc_no == GC_gc_no)) { ++ ENTER_GC(); ++ GC_collect_a_little_inner(1); ++ EXIT_GC(); ++ UNLOCK(); ++ sched_yield(); ++ LOCK(); ++ } ++ } ++} ++ ++#ifdef HANDLE_FORK ++/* Procedures called before and after a fork. The goal here is to make */ ++/* it safe to call GC_malloc() in a forked child. It's unclear that is */ ++/* attainable, since the single UNIX spec seems to imply that one */ ++/* should only call async-signal-safe functions, and we probably can't */ ++/* quite guarantee that. But we give it our best shot. (That same */ ++/* spec also implies that it's not safe to call the system malloc */ ++/* between fork() and exec(). Thus we're doing no worse than it. */ ++ ++/* Called before a fork() */ ++void GC_fork_prepare_proc(void) ++{ ++ /* Acquire all relevant locks, so that after releasing the locks */ ++ /* the child will see a consistent state in which monitor */ ++ /* invariants hold. Unfortunately, we can't acquire libc locks */ ++ /* we might need, and there seems to be no guarantee that libc */ ++ /* must install a suitable fork handler. */ ++ /* Wait for an ongoing GC to finish, since we can't finish it in */ ++ /* the (one remaining thread in) the child. */ ++ LOCK(); ++# if defined(PARALLEL_MARK) || defined(THREAD_LOCAL_ALLOC) ++ GC_wait_for_reclaim(); ++# endif ++ GC_wait_for_gc_completion(TRUE); ++# if defined(PARALLEL_MARK) || defined(THREAD_LOCAL_ALLOC) ++ GC_acquire_mark_lock(); ++# endif ++} ++ ++/* Called in parent after a fork() */ ++void GC_fork_parent_proc(void) ++{ ++# if defined(PARALLEL_MARK) || defined(THREAD_LOCAL_ALLOC) ++ GC_release_mark_lock(); ++# endif ++ UNLOCK(); ++} ++ ++/* Called in child after a fork() */ ++void GC_fork_child_proc(void) ++{ ++ /* Clean up the thread table, so that just our thread is left. */ ++# if defined(PARALLEL_MARK) || defined(THREAD_LOCAL_ALLOC) ++ GC_release_mark_lock(); ++# endif ++ GC_remove_all_threads_but_me(); ++# ifdef PARALLEL_MARK ++ /* Turn off parallel marking in the child, since we are probably */ ++ /* just going to exec, and we would have to restart mark threads. */ ++ GC_markers = 1; ++ GC_parallel = FALSE; ++# endif /* PARALLEL_MARK */ ++ UNLOCK(); ++} ++#endif /* HANDLE_FORK */ ++ ++#if defined(GC_DGUX386_THREADS) ++/* Return the number of processors, or i<= 0 if it can't be determined. */ ++int GC_get_nprocs() ++{ ++ /* */ ++ int numCpus; ++ struct dg_sys_info_pm_info pm_sysinfo; ++ int status =0; ++ ++ status = dg_sys_info((long int *) &pm_sysinfo, ++ DG_SYS_INFO_PM_INFO_TYPE, DG_SYS_INFO_PM_CURRENT_VERSION); ++ if (status < 0) ++ /* set -1 for error */ ++ numCpus = -1; ++ else ++ /* Active CPUs */ ++ numCpus = pm_sysinfo.idle_vp_count; ++ ++# ifdef DEBUG_THREADS ++ GC_printf1("Number of active CPUs in this system: %d\n", numCpus); ++# endif ++ return(numCpus); ++} ++#endif /* GC_DGUX386_THREADS */ ++ ++/* We hold the allocation lock. */ ++void GC_thr_init() ++{ ++# ifndef GC_DARWIN_THREADS ++ int dummy; ++# endif ++ GC_thread t; ++ ++ if (GC_thr_initialized) return; ++ GC_thr_initialized = TRUE; ++ ++# ifdef HANDLE_FORK ++ /* Prepare for a possible fork. */ ++ pthread_atfork(GC_fork_prepare_proc, GC_fork_parent_proc, ++ GC_fork_child_proc); ++# endif /* HANDLE_FORK */ ++ /* Add the initial thread, so we can stop it. */ ++ t = GC_new_thread(pthread_self()); ++# ifdef GC_DARWIN_THREADS ++ t -> stop_info.mach_thread = mach_thread_self(); ++# else ++ t -> stop_info.stack_ptr = (ptr_t)(&dummy); ++# endif ++ t -> flags = DETACHED | MAIN_THREAD; ++ ++ GC_stop_init(); ++ ++ /* Set GC_nprocs. */ ++ { ++ char * nprocs_string = GETENV("GC_NPROCS"); ++ GC_nprocs = -1; ++ if (nprocs_string != NULL) GC_nprocs = atoi(nprocs_string); ++ } ++ if (GC_nprocs <= 0) { ++# if defined(GC_HPUX_THREADS) ++ GC_nprocs = pthread_num_processors_np(); ++# endif ++# if defined(GC_OSF1_THREADS) ++ GC_nprocs = sysconf(_SC_NPROCESSORS_ONLN); ++ if (GC_nprocs <= 0) GC_nprocs = 1; ++# endif ++# if defined(GC_FREEBSD_THREADS) ++ GC_nprocs = 1; ++# endif ++# if defined(GC_DARWIN_THREADS) ++ int ncpus = 1; ++ size_t len = sizeof(ncpus); ++ sysctl((int[2]) {CTL_HW, HW_NCPU}, 2, &ncpus, &len, NULL, 0); ++ GC_nprocs = ncpus; ++# endif ++# if defined(GC_LINUX_THREADS) || defined(GC_DGUX386_THREADS) ++ GC_nprocs = GC_get_nprocs(); ++# endif ++ } ++ if (GC_nprocs <= 0) { ++ WARN("GC_get_nprocs() returned %ld\n", GC_nprocs); ++ GC_nprocs = 2; ++# ifdef PARALLEL_MARK ++ GC_markers = 1; ++# endif ++ } else { ++# ifdef PARALLEL_MARK ++ { ++ char * markers_string = GETENV("GC_MARKERS"); ++ if (markers_string != NULL) { ++ GC_markers = atoi(markers_string); ++ } else { ++ GC_markers = GC_nprocs; ++ } ++ } ++# endif ++ } ++# ifdef PARALLEL_MARK ++# ifdef CONDPRINT ++ if (GC_print_stats) { ++ GC_printf2("Number of processors = %ld, " ++ "number of marker threads = %ld\n", GC_nprocs, GC_markers); ++ } ++# endif ++ if (GC_markers == 1) { ++ GC_parallel = FALSE; ++# ifdef CONDPRINT ++ if (GC_print_stats) { ++ GC_printf0("Single marker thread, turning off parallel marking\n"); ++ } ++# endif ++ } else { ++ GC_parallel = TRUE; ++ /* Disable true incremental collection, but generational is OK. */ ++ GC_time_limit = GC_TIME_UNLIMITED; ++ } ++# endif ++} ++ ++ ++/* Perform all initializations, including those that */ ++/* may require allocation. */ ++/* Called without allocation lock. */ ++/* Must be called before a second thread is created. */ ++/* Called without allocation lock. */ ++void GC_init_parallel() ++{ ++ if (parallel_initialized) return; ++ parallel_initialized = TRUE; ++ ++ /* GC_init() calls us back, so set flag first. */ ++ if (!GC_is_initialized) GC_init(); ++ /* If we are using a parallel marker, start the helper threads. */ ++# ifdef PARALLEL_MARK ++ if (GC_parallel) start_mark_threads(); ++# endif ++ /* Initialize thread local free lists if used. */ ++# if defined(THREAD_LOCAL_ALLOC) && !defined(DBG_HDRS_ALL) ++ LOCK(); ++ GC_init_thread_local(GC_lookup_thread(pthread_self())); ++ UNLOCK(); ++# endif ++} ++ ++ ++#if !defined(GC_DARWIN_THREADS) ++int WRAP_FUNC(pthread_sigmask)(int how, const sigset_t *set, sigset_t *oset) ++{ ++ sigset_t fudged_set; ++ ++ if (set != NULL && (how == SIG_BLOCK || how == SIG_SETMASK)) { ++ fudged_set = *set; ++ sigdelset(&fudged_set, SIG_SUSPEND); ++ set = &fudged_set; ++ } ++ return(REAL_FUNC(pthread_sigmask)(how, set, oset)); ++} ++#endif /* !GC_DARWIN_THREADS */ ++ ++/* Wrappers for functions that are likely to block for an appreciable */ ++/* length of time. Must be called in pairs, if at all. */ ++/* Nothing much beyond the system call itself should be executed */ ++/* between these. */ ++ ++void GC_start_blocking(void) { ++# define SP_SLOP 128 ++ GC_thread me; ++ LOCK(); ++ me = GC_lookup_thread(pthread_self()); ++ GC_ASSERT(!(me -> thread_blocked)); ++# ifdef SPARC ++ me -> stop_info.stack_ptr = (ptr_t)GC_save_regs_in_stack(); ++# else ++# ifndef GC_DARWIN_THREADS ++ me -> stop_info.stack_ptr = (ptr_t)GC_approx_sp(); ++# endif ++# endif ++# ifdef IA64 ++ me -> backing_store_ptr = (ptr_t)GC_save_regs_in_stack() + SP_SLOP; ++# endif ++ /* Add some slop to the stack pointer, since the wrapped call may */ ++ /* end up pushing more callee-save registers. */ ++# ifndef GC_DARWIN_THREADS ++# ifdef STACK_GROWS_UP ++ me -> stop_info.stack_ptr += SP_SLOP; ++# else ++ me -> stop_info.stack_ptr -= SP_SLOP; ++# endif ++# endif ++ me -> thread_blocked = TRUE; ++ UNLOCK(); ++} ++ ++void GC_end_blocking(void) { ++ GC_thread me; ++ LOCK(); /* This will block if the world is stopped. */ ++ me = GC_lookup_thread(pthread_self()); ++ GC_ASSERT(me -> thread_blocked); ++ me -> thread_blocked = FALSE; ++ UNLOCK(); ++} ++ ++#if defined(GC_DGUX386_THREADS) ++#define __d10_sleep sleep ++#endif /* GC_DGUX386_THREADS */ ++ ++/* A wrapper for the standard C sleep function */ ++int WRAP_FUNC(sleep) (unsigned int seconds) ++{ ++ int result; ++ ++ GC_start_blocking(); ++ result = REAL_FUNC(sleep)(seconds); ++ GC_end_blocking(); ++ return result; ++} ++ ++struct start_info { ++ void *(*start_routine)(void *); ++ void *arg; ++ word flags; ++ sem_t registered; /* 1 ==> in our thread table, but */ ++ /* parent hasn't yet noticed. */ ++}; ++ ++/* Called at thread exit. */ ++/* Never called for main thread. That's OK, since it */ ++/* results in at most a tiny one-time leak. And */ ++/* linuxthreads doesn't reclaim the main threads */ ++/* resources or id anyway. */ ++void GC_thread_exit_proc(void *arg) ++{ ++ GC_thread me; ++ ++ LOCK(); ++ me = GC_lookup_thread(pthread_self()); ++ GC_destroy_thread_local(me); ++ if (me -> flags & DETACHED) { ++ GC_delete_thread(pthread_self()); ++ } else { ++ me -> flags |= FINISHED; ++ } ++# if defined(THREAD_LOCAL_ALLOC) && !defined(USE_PTHREAD_SPECIFIC) \ ++ && !defined(USE_HPUX_TLS) && !defined(DBG_HDRS_ALL) ++ GC_remove_specific(GC_thread_key); ++# endif ++ GC_wait_for_gc_completion(FALSE); ++ UNLOCK(); ++} ++ ++int WRAP_FUNC(pthread_join)(pthread_t thread, void **retval) ++{ ++ int result; ++ GC_thread thread_gc_id; ++ ++ LOCK(); ++ thread_gc_id = GC_lookup_thread(thread); ++ /* This is guaranteed to be the intended one, since the thread id */ ++ /* cant have been recycled by pthreads. */ ++ UNLOCK(); ++ result = REAL_FUNC(pthread_join)(thread, retval); ++# if defined (GC_FREEBSD_THREADS) ++ /* On FreeBSD, the wrapped pthread_join() sometimes returns (what ++ appears to be) a spurious EINTR which caused the test and real code ++ to gratuitously fail. Having looked at system pthread library source ++ code, I see how this return code may be generated. In one path of ++ code, pthread_join() just returns the errno setting of the thread ++ being joined. This does not match the POSIX specification or the ++ local man pages thus I have taken the liberty to catch this one ++ spurious return value properly conditionalized on GC_FREEBSD_THREADS. */ ++ if (result == EINTR) result = 0; ++# endif ++ if (result == 0) { ++ LOCK(); ++ /* Here the pthread thread id may have been recycled. */ ++ GC_delete_gc_thread(thread, thread_gc_id); ++ UNLOCK(); ++ } ++ return result; ++} ++ ++int ++WRAP_FUNC(pthread_detach)(pthread_t thread) ++{ ++ int result; ++ GC_thread thread_gc_id; ++ ++ LOCK(); ++ thread_gc_id = GC_lookup_thread(thread); ++ UNLOCK(); ++ result = REAL_FUNC(pthread_detach)(thread); ++ if (result == 0) { ++ LOCK(); ++ thread_gc_id -> flags |= DETACHED; ++ /* Here the pthread thread id may have been recycled. */ ++ if (thread_gc_id -> flags & FINISHED) { ++ GC_delete_gc_thread(thread, thread_gc_id); ++ } ++ UNLOCK(); ++ } ++ return result; ++} ++ ++void * GC_start_routine(void * arg) ++{ ++ int dummy; ++ struct start_info * si = arg; ++ void * result; ++ GC_thread me; ++ pthread_t my_pthread; ++ void *(*start)(void *); ++ void *start_arg; ++ ++ my_pthread = pthread_self(); ++# ifdef DEBUG_THREADS ++ GC_printf1("Starting thread 0x%lx\n", my_pthread); ++ GC_printf1("pid = %ld\n", (long) getpid()); ++ GC_printf1("sp = 0x%lx\n", (long) &arg); ++# endif ++ LOCK(); ++ me = GC_new_thread(my_pthread); ++#ifdef GC_DARWIN_THREADS ++ me -> stop_info.mach_thread = mach_thread_self(); ++#else ++ me -> stop_info.stack_ptr = 0; ++#endif ++ me -> flags = si -> flags; ++ /* me -> stack_end = GC_linux_stack_base(); -- currently (11/99) */ ++ /* doesn't work because the stack base in /proc/self/stat is the */ ++ /* one for the main thread. There is a strong argument that that's */ ++ /* a kernel bug, but a pervasive one. */ ++# ifdef STACK_GROWS_DOWN ++ me -> stack_end = (ptr_t)(((word)(&dummy) + (GC_page_size - 1)) ++ & ~(GC_page_size - 1)); ++# ifndef GC_DARWIN_THREADS ++ me -> stop_info.stack_ptr = me -> stack_end - 0x10; ++# endif ++ /* Needs to be plausible, since an asynchronous stack mark */ ++ /* should not crash. */ ++# else ++ me -> stack_end = (ptr_t)((word)(&dummy) & ~(GC_page_size - 1)); ++ me -> stop_info.stack_ptr = me -> stack_end + 0x10; ++# endif ++ /* This is dubious, since we may be more than a page into the stack, */ ++ /* and hence skip some of it, though it's not clear that matters. */ ++# ifdef IA64 ++ me -> backing_store_end = (ptr_t) ++ (GC_save_regs_in_stack() & ~(GC_page_size - 1)); ++ /* This is also < 100% convincing. We should also read this */ ++ /* from /proc, but the hook to do so isn't there yet. */ ++# endif /* IA64 */ ++ UNLOCK(); ++ start = si -> start_routine; ++# ifdef DEBUG_THREADS ++ GC_printf1("start_routine = 0x%lx\n", start); ++# endif ++ start_arg = si -> arg; ++ sem_post(&(si -> registered)); /* Last action on si. */ ++ /* OK to deallocate. */ ++ pthread_cleanup_push(GC_thread_exit_proc, 0); ++# if defined(THREAD_LOCAL_ALLOC) && !defined(DBG_HDRS_ALL) ++ LOCK(); ++ GC_init_thread_local(me); ++ UNLOCK(); ++# endif ++ result = (*start)(start_arg); ++#if DEBUG_THREADS ++ GC_printf1("Finishing thread 0x%x\n", pthread_self()); ++#endif ++ me -> status = result; ++ me -> flags |= FINISHED; ++ pthread_cleanup_pop(1); ++ /* Cleanup acquires lock, ensuring that we can't exit */ ++ /* while a collection that thinks we're alive is trying to stop */ ++ /* us. */ ++ return(result); ++} ++ ++int ++WRAP_FUNC(pthread_create)(pthread_t *new_thread, ++ const pthread_attr_t *attr, ++ void *(*start_routine)(void *), void *arg) ++{ ++ int result; ++ int detachstate; ++ word my_flags = 0; ++ struct start_info * si; ++ /* This is otherwise saved only in an area mmapped by the thread */ ++ /* library, which isn't visible to the collector. */ ++ ++ /* We resist the temptation to muck with the stack size here, */ ++ /* even if the default is unreasonably small. That's the client's */ ++ /* responsibility. */ ++ ++ LOCK(); ++ si = (struct start_info *)GC_INTERNAL_MALLOC(sizeof(struct start_info), ++ NORMAL); ++ UNLOCK(); ++ if (!parallel_initialized) GC_init_parallel(); ++ if (0 == si) return(ENOMEM); ++ sem_init(&(si -> registered), 0, 0); ++ si -> start_routine = start_routine; ++ si -> arg = arg; ++ LOCK(); ++ if (!GC_thr_initialized) GC_thr_init(); ++# ifdef GC_ASSERTIONS ++ { ++ int stack_size; ++ if (NULL == attr) { ++ pthread_attr_t my_attr; ++ pthread_attr_init(&my_attr); ++ pthread_attr_getstacksize(&my_attr, &stack_size); ++ } else { ++ pthread_attr_getstacksize(attr, &stack_size); ++ } ++ GC_ASSERT(stack_size >= (8*HBLKSIZE*sizeof(word))); ++ /* Our threads may need to do some work for the GC. */ ++ /* Ridiculously small threads won't work, and they */ ++ /* probably wouldn't work anyway. */ ++ } ++# endif ++ if (NULL == attr) { ++ detachstate = PTHREAD_CREATE_JOINABLE; ++ } else { ++ pthread_attr_getdetachstate(attr, &detachstate); ++ } ++ if (PTHREAD_CREATE_DETACHED == detachstate) my_flags |= DETACHED; ++ si -> flags = my_flags; ++ UNLOCK(); ++# ifdef DEBUG_THREADS ++ GC_printf1("About to start new thread from thread 0x%X\n", ++ pthread_self()); ++# endif ++ ++ result = REAL_FUNC(pthread_create)(new_thread, attr, GC_start_routine, si); ++ ++# ifdef DEBUG_THREADS ++ GC_printf1("Started thread 0x%X\n", *new_thread); ++# endif ++ /* Wait until child has been added to the thread table. */ ++ /* This also ensures that we hold onto si until the child is done */ ++ /* with it. Thus it doesn't matter whether it is otherwise */ ++ /* visible to the collector. */ ++ while (0 != sem_wait(&(si -> registered))) { ++ if (EINTR != errno) ABORT("sem_wait failed"); ++ } ++ sem_destroy(&(si -> registered)); ++ LOCK(); ++ GC_INTERNAL_FREE(si); ++ UNLOCK(); ++ ++ return(result); ++} ++ ++#ifdef GENERIC_COMPARE_AND_SWAP ++ pthread_mutex_t GC_compare_and_swap_lock = PTHREAD_MUTEX_INITIALIZER; ++ ++ GC_bool GC_compare_and_exchange(volatile GC_word *addr, ++ GC_word old, GC_word new_val) ++ { ++ GC_bool result; ++ pthread_mutex_lock(&GC_compare_and_swap_lock); ++ if (*addr == old) { ++ *addr = new_val; ++ result = TRUE; ++ } else { ++ result = FALSE; ++ } ++ pthread_mutex_unlock(&GC_compare_and_swap_lock); ++ return result; ++ } ++ ++ GC_word GC_atomic_add(volatile GC_word *addr, GC_word how_much) ++ { ++ GC_word old; ++ pthread_mutex_lock(&GC_compare_and_swap_lock); ++ old = *addr; ++ *addr = old + how_much; ++ pthread_mutex_unlock(&GC_compare_and_swap_lock); ++ return old; ++ } ++ ++#endif /* GENERIC_COMPARE_AND_SWAP */ ++/* Spend a few cycles in a way that can't introduce contention with */ ++/* othre threads. */ ++void GC_pause() ++{ ++ int i; ++# ifndef __GNUC__ ++ volatile word dummy = 0; ++# endif ++ ++ for (i = 0; i < 10; ++i) { ++# ifdef __GNUC__ ++ __asm__ __volatile__ (" " : : : "memory"); ++# else ++ /* Something that's unlikely to be optimized away. */ ++ GC_noop(++dummy); ++# endif ++ } ++} ++ ++#define SPIN_MAX 1024 /* Maximum number of calls to GC_pause before */ ++ /* give up. */ ++ ++VOLATILE GC_bool GC_collecting = 0; ++ /* A hint that we're in the collector and */ ++ /* holding the allocation lock for an */ ++ /* extended period. */ ++ ++#if !defined(USE_SPIN_LOCK) || defined(PARALLEL_MARK) ++/* If we don't want to use the below spinlock implementation, either */ ++/* because we don't have a GC_test_and_set implementation, or because */ ++/* we don't want to risk sleeping, we can still try spinning on */ ++/* pthread_mutex_trylock for a while. This appears to be very */ ++/* beneficial in many cases. */ ++/* I suspect that under high contention this is nearly always better */ ++/* than the spin lock. But it's a bit slower on a uniprocessor. */ ++/* Hence we still default to the spin lock. */ ++/* This is also used to acquire the mark lock for the parallel */ ++/* marker. */ ++ ++/* Here we use a strict exponential backoff scheme. I don't know */ ++/* whether that's better or worse than the above. We eventually */ ++/* yield by calling pthread_mutex_lock(); it never makes sense to */ ++/* explicitly sleep. */ ++ ++void GC_generic_lock(pthread_mutex_t * lock) ++{ ++#ifndef NO_PTHREAD_TRYLOCK ++ unsigned pause_length = 1; ++ unsigned i; ++ ++ if (0 == pthread_mutex_trylock(lock)) return; ++ for (; pause_length <= SPIN_MAX; pause_length <<= 1) { ++ for (i = 0; i < pause_length; ++i) { ++ GC_pause(); ++ } ++ switch(pthread_mutex_trylock(lock)) { ++ case 0: ++ return; ++ case EBUSY: ++ break; ++ default: ++ ABORT("Unexpected error from pthread_mutex_trylock"); ++ } ++ } ++#endif /* !NO_PTHREAD_TRYLOCK */ ++ pthread_mutex_lock(lock); ++} ++ ++#endif /* !USE_SPIN_LOCK || PARALLEL_MARK */ ++ ++#if defined(USE_SPIN_LOCK) ++ ++/* Reasonably fast spin locks. Basically the same implementation */ ++/* as STL alloc.h. This isn't really the right way to do this. */ ++/* but until the POSIX scheduling mess gets straightened out ... */ ++ ++volatile unsigned int GC_allocate_lock = 0; ++ ++ ++void GC_lock() ++{ ++# define low_spin_max 30 /* spin cycles if we suspect uniprocessor */ ++# define high_spin_max SPIN_MAX /* spin cycles for multiprocessor */ ++ static unsigned spin_max = low_spin_max; ++ unsigned my_spin_max; ++ static unsigned last_spins = 0; ++ unsigned my_last_spins; ++ int i; ++ ++ if (!GC_test_and_set(&GC_allocate_lock)) { ++ return; ++ } ++ my_spin_max = spin_max; ++ my_last_spins = last_spins; ++ for (i = 0; i < my_spin_max; i++) { ++ if (GC_collecting || GC_nprocs == 1) goto yield; ++ if (i < my_last_spins/2 || GC_allocate_lock) { ++ GC_pause(); ++ continue; ++ } ++ if (!GC_test_and_set(&GC_allocate_lock)) { ++ /* ++ * got it! ++ * Spinning worked. Thus we're probably not being scheduled ++ * against the other process with which we were contending. ++ * Thus it makes sense to spin longer the next time. ++ */ ++ last_spins = i; ++ spin_max = high_spin_max; ++ return; ++ } ++ } ++ /* We are probably being scheduled against the other process. Sleep. */ ++ spin_max = low_spin_max; ++yield: ++ for (i = 0;; ++i) { ++ if (!GC_test_and_set(&GC_allocate_lock)) { ++ return; ++ } ++# define SLEEP_THRESHOLD 12 ++ /* Under Linux very short sleeps tend to wait until */ ++ /* the current time quantum expires. On old Linux */ ++ /* kernels nanosleep(<= 2ms) just spins under Linux. */ ++ /* (Under 2.4, this happens only for real-time */ ++ /* processes.) We want to minimize both behaviors */ ++ /* here. */ ++ if (i < SLEEP_THRESHOLD) { ++ sched_yield(); ++ } else { ++ struct timespec ts; ++ ++ if (i > 24) i = 24; ++ /* Don't wait for more than about 15msecs, even */ ++ /* under extreme contention. */ ++ ts.tv_sec = 0; ++ ts.tv_nsec = 1 << i; ++ nanosleep(&ts, 0); ++ } ++ } ++} ++ ++#else /* !USE_SPINLOCK */ ++void GC_lock() ++{ ++#ifndef NO_PTHREAD_TRYLOCK ++ if (1 == GC_nprocs || GC_collecting) { ++ pthread_mutex_lock(&GC_allocate_ml); ++ } else { ++ GC_generic_lock(&GC_allocate_ml); ++ } ++#else /* !NO_PTHREAD_TRYLOCK */ ++ pthread_mutex_lock(&GC_allocate_ml); ++#endif /* !NO_PTHREAD_TRYLOCK */ ++} ++ ++#endif /* !USE_SPINLOCK */ ++ ++#if defined(PARALLEL_MARK) || defined(THREAD_LOCAL_ALLOC) ++ ++#ifdef GC_ASSERTIONS ++ pthread_t GC_mark_lock_holder = NO_THREAD; ++#endif ++ ++#if 0 ++ /* Ugly workaround for a linux threads bug in the final versions */ ++ /* of glibc2.1. Pthread_mutex_trylock sets the mutex owner */ ++ /* field even when it fails to acquire the mutex. This causes */ ++ /* pthread_cond_wait to die. Remove for glibc2.2. */ ++ /* According to the man page, we should use */ ++ /* PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP, but that isn't actually */ ++ /* defined. */ ++ static pthread_mutex_t mark_mutex = ++ {0, 0, 0, PTHREAD_MUTEX_ERRORCHECK_NP, {0, 0}}; ++#else ++ static pthread_mutex_t mark_mutex = PTHREAD_MUTEX_INITIALIZER; ++#endif ++ ++static pthread_cond_t builder_cv = PTHREAD_COND_INITIALIZER; ++ ++void GC_acquire_mark_lock() ++{ ++/* ++ if (pthread_mutex_lock(&mark_mutex) != 0) { ++ ABORT("pthread_mutex_lock failed"); ++ } ++*/ ++ GC_generic_lock(&mark_mutex); ++# ifdef GC_ASSERTIONS ++ GC_mark_lock_holder = pthread_self(); ++# endif ++} ++ ++void GC_release_mark_lock() ++{ ++ GC_ASSERT(GC_mark_lock_holder == pthread_self()); ++# ifdef GC_ASSERTIONS ++ GC_mark_lock_holder = NO_THREAD; ++# endif ++ if (pthread_mutex_unlock(&mark_mutex) != 0) { ++ ABORT("pthread_mutex_unlock failed"); ++ } ++} ++ ++/* Collector must wait for a freelist builders for 2 reasons: */ ++/* 1) Mark bits may still be getting examined without lock. */ ++/* 2) Partial free lists referenced only by locals may not be scanned */ ++/* correctly, e.g. if they contain "pointer-free" objects, since the */ ++/* free-list link may be ignored. */ ++void GC_wait_builder() ++{ ++ GC_ASSERT(GC_mark_lock_holder == pthread_self()); ++# ifdef GC_ASSERTIONS ++ GC_mark_lock_holder = NO_THREAD; ++# endif ++ if (pthread_cond_wait(&builder_cv, &mark_mutex) != 0) { ++ ABORT("pthread_cond_wait failed"); ++ } ++ GC_ASSERT(GC_mark_lock_holder == NO_THREAD); ++# ifdef GC_ASSERTIONS ++ GC_mark_lock_holder = pthread_self(); ++# endif ++} ++ ++void GC_wait_for_reclaim() ++{ ++ GC_acquire_mark_lock(); ++ while (GC_fl_builder_count > 0) { ++ GC_wait_builder(); ++ } ++ GC_release_mark_lock(); ++} ++ ++void GC_notify_all_builder() ++{ ++ GC_ASSERT(GC_mark_lock_holder == pthread_self()); ++ if (pthread_cond_broadcast(&builder_cv) != 0) { ++ ABORT("pthread_cond_broadcast failed"); ++ } ++} ++ ++#endif /* PARALLEL_MARK || THREAD_LOCAL_ALLOC */ ++ ++#ifdef PARALLEL_MARK ++ ++static pthread_cond_t mark_cv = PTHREAD_COND_INITIALIZER; ++ ++void GC_wait_marker() ++{ ++ GC_ASSERT(GC_mark_lock_holder == pthread_self()); ++# ifdef GC_ASSERTIONS ++ GC_mark_lock_holder = NO_THREAD; ++# endif ++ if (pthread_cond_wait(&mark_cv, &mark_mutex) != 0) { ++ ABORT("pthread_cond_wait failed"); ++ } ++ GC_ASSERT(GC_mark_lock_holder == NO_THREAD); ++# ifdef GC_ASSERTIONS ++ GC_mark_lock_holder = pthread_self(); ++# endif ++} ++ ++void GC_notify_all_marker() ++{ ++ if (pthread_cond_broadcast(&mark_cv) != 0) { ++ ABORT("pthread_cond_broadcast failed"); ++ } ++} ++ ++#endif /* PARALLEL_MARK */ ++ ++# endif /* GC_LINUX_THREADS and friends */ ++ +diff -urNb boehm-gc/ptr_chck.c boehm-gc/ptr_chck.c +--- boehm-gc/ptr_chck.c Fri Aug 17 11:30:46 2001 ++++ boehm-gc/ptr_chck.c Mon May 26 12:48:52 2003 +@@ -79,7 +79,7 @@ + return(p); + } + sz = WORDS_TO_BYTES(hhdr -> hb_sz); +- if (sz > WORDS_TO_BYTES(MAXOBJSZ)) { ++ if (sz > MAXOBJBYTES) { + base = (ptr_t)HBLKPTR(p); + limit = base + sz; + if ((ptr_t)p >= limit) { +@@ -165,7 +165,7 @@ + pdispl = HBLKDISPL(p); + map_entry = MAP_ENTRY((hhdr -> hb_map), pdispl); + if (map_entry == OBJ_INVALID +- || sz > MAXOBJSZ && (ptr_t)p >= (ptr_t)h + sz) { ++ || sz > MAXOBJBYTES && (ptr_t)p >= (ptr_t)h + sz) { + goto fail; + } + return(p); +diff -urNb boehm-gc/reclaim.c boehm-gc/reclaim.c +--- boehm-gc/reclaim.c Fri Mar 29 14:52:12 2002 ++++ boehm-gc/reclaim.c Mon May 26 12:48:52 2003 +@@ -27,10 +27,43 @@ + /* nonzero. */ + #endif /* PARALLEL_MARK */ + +-static void report_leak(p, sz) +-ptr_t p; +-word sz; ++/* We defer printing of leaked objects until we're done with the GC */ ++/* cycle, since the routine for printing objects needs to run outside */ ++/* the collector, e.g. without the allocation lock. */ ++#define MAX_LEAKED 40 ++ptr_t GC_leaked[MAX_LEAKED]; ++unsigned GC_n_leaked = 0; ++ ++GC_bool GC_have_errors = FALSE; ++ ++void GC_add_leaked(leaked) ++ptr_t leaked; ++{ ++ if (GC_n_leaked < MAX_LEAKED) { ++ GC_have_errors = TRUE; ++ GC_leaked[GC_n_leaked++] = leaked; ++ /* Make sure it's not reclaimed this cycle */ ++ GC_set_mark_bit(leaked); ++ } ++} ++ ++static GC_bool printing_errors = FALSE; ++/* Print all objects on the list after printing any smashed objs. */ ++/* Clear both lists. */ ++void GC_print_all_errors () + { ++ unsigned i; ++ ++ LOCK(); ++ if (printing_errors) { ++ UNLOCK(); ++ return; ++ } ++ printing_errors = TRUE; ++ UNLOCK(); ++ if (GC_debugging_started) GC_print_all_smashed(); ++ for (i = 0; i < GC_n_leaked; ++i) { ++ ptr_t p = GC_leaked[i]; + if (HDR(p) -> hb_obj_kind == PTRFREE) { + GC_err_printf0("Leaked atomic object at "); + } else { +@@ -38,12 +71,17 @@ + } + GC_print_heap_obj(p); + GC_err_printf0("\n"); ++ GC_free(p); ++ GC_leaked[i] = 0; ++ } ++ GC_n_leaked = 0; ++ printing_errors = FALSE; + } + ++ + # define FOUND_FREE(hblk, word_no) \ + { \ +- report_leak((ptr_t)hblk + WORDS_TO_BYTES(word_no), \ +- HDR(hblk) -> hb_sz); \ ++ GC_add_leaked((ptr_t)hblk + WORDS_TO_BYTES(word_no)); \ + } + + /* +@@ -866,7 +904,7 @@ + * Clear *flp. + * This must be done before dropping a list of free gcj-style objects, + * since may otherwise end up with dangling "descriptor" pointers. +- * It may help for other pointer-containg objects. ++ * It may help for other pointer-containing objects. + */ + void GC_clear_fl_links(flp) + ptr_t *flp; +diff -urNb boehm-gc/solaris_pthreads.c boehm-gc/solaris_pthreads.c +--- boehm-gc/solaris_pthreads.c Mon Feb 11 20:37:53 2002 ++++ boehm-gc/solaris_pthreads.c Mon May 26 12:48:52 2003 +@@ -13,9 +13,8 @@ + /* + * Support code for Solaris threads. Provides functionality we wish Sun + * had provided. Relies on some information we probably shouldn't rely on. +- * Modified Peter C. for Solaris Posix Threads. ++ * Modified by Peter C. for Solaris Posix Threads. + */ +-/* Boehm, September 14, 1994 4:44 pm PDT */ + + # if defined(GC_SOLARIS_PTHREADS) + # include "private/gc_priv.h" +diff -urNb boehm-gc/solaris_threads.c boehm-gc/solaris_threads.c +--- boehm-gc/solaris_threads.c Mon Feb 11 20:37:53 2002 ++++ boehm-gc/solaris_threads.c Mon May 26 12:48:52 2003 +@@ -37,6 +37,10 @@ + # include + # include + ++#ifdef HANDLE_FORK ++ --> Not yet supported. Try porting the code from linux_threads.c. ++#endif ++ + /* + * This is the default size of the LWP arrays. If there are more LWPs + * than this when a stop-the-world GC happens, set_max_lwps will be +@@ -361,7 +365,7 @@ + sizeof (prgregset_t)) != 0) { + int j; + +- for(j = 0; j < NGREG; j++) ++ for(j = 0; j < NPRGREG; j++) + { + GC_printf3("%i: %x -> %x\n", j, + GC_lwp_registers[i][j], +@@ -821,7 +825,7 @@ + if (result == 0) { + t = GC_lookup_thread(target_thread); + if (t == 0) ABORT("thread unknown to GC"); +- t -> flags |= SUSPENDED; ++ t -> flags |= SUSPNDED; + } + UNLOCK(); + return(result); +@@ -837,7 +841,7 @@ + if (result == 0) { + t = GC_lookup_thread(target_thread); + if (t == 0) ABORT("thread unknown to GC"); +- t -> flags &= ~SUSPENDED; ++ t -> flags &= ~SUSPNDED; + } + UNLOCK(); + return(result); +@@ -923,7 +927,7 @@ + my_flags |= CLIENT_OWNS_STACK; + } + if (flags & THR_DETACHED) my_flags |= DETACHED; +- if (flags & THR_SUSPENDED) my_flags |= SUSPENDED; ++ if (flags & THR_SUSPENDED) my_flags |= SUSPNDED; + result = thr_create(stack, stack_size, start_routine, + arg, flags & ~THR_DETACHED, &my_new_thread); + if (result == 0) { +diff -urNb boehm-gc/threadlibs.c boehm-gc/threadlibs.c +--- boehm-gc/threadlibs.c Mon Feb 11 20:37:53 2002 ++++ boehm-gc/threadlibs.c Mon May 26 12:48:52 2003 +@@ -4,13 +4,14 @@ + int main() + { + # if defined(GC_USE_LD_WRAP) +- printf("-Wl,--wrap -Wl,read -Wl,--wrap -Wl,dlopen " ++ printf("-Wl,--wrap -Wl,dlopen " + "-Wl,--wrap -Wl,pthread_create -Wl,--wrap -Wl,pthread_join " + "-Wl,--wrap -Wl,pthread_detach " + "-Wl,--wrap -Wl,pthread_sigmask -Wl,--wrap -Wl,sleep\n"); + # endif + # if defined(GC_LINUX_THREADS) || defined(GC_IRIX_THREADS) \ +- || defined(GC_FREEBSD_THREADS) || defined(GC_SOLARIS_PTHREADS) ++ || defined(GC_FREEBSD_THREADS) || defined(GC_SOLARIS_PTHREADS) \ ++ || defined(GC_MACOSX_THREADS) + printf("-lpthread\n"); + # endif + # if defined(GC_HPUX_THREADS) || defined(GC_OSF1_THREADS) +@@ -18,6 +19,17 @@ + # endif + # if defined(GC_SOLARIS_THREADS) && !defined(GC_SOLARIS_PTHREADS) + printf("-lthread -ldl\n"); ++# endif ++# if defined(GC_WIN32_THREADS) && defined(CYGWIN32) ++ printf("-lpthread\n"); ++# endif ++# if defined(GC_OSF1_THREADS) ++ printf("-lpthread -lrt"); ++# endif ++ /* You need GCC 3.0.3 to build this one! */ ++ /* DG/UX native gcc doesnt know what "-pthread" is */ ++# if defined(GC_DGUX386_THREADS) ++ printf("-ldl -pthread\n"); + # endif + return 0; + } +diff -urNb boehm-gc/typd_mlc.c boehm-gc/typd_mlc.c +--- boehm-gc/typd_mlc.c Fri Aug 17 11:30:46 2001 ++++ boehm-gc/typd_mlc.c Mon May 26 12:48:52 2003 +@@ -437,6 +437,7 @@ + for (; bm != 0; bm >>= 1, current_p++) { + if (bm & 1) { + current = *current_p; ++ FIXUP_POINTER(current); + if ((ptr_t)current >= least_ha && (ptr_t)current <= greatest_ha) { + PUSH_CONTENTS((ptr_t)current, mark_stack_ptr, + mark_stack_limit, current_p, exit1); +@@ -674,7 +675,7 @@ + if( !FASTLOCK_SUCCEEDED() || (op = *opp) == 0 ) { + FASTUNLOCK(); + op = (ptr_t)GENERAL_MALLOC((word)lb, GC_explicit_kind); +- if (0 == op) return(0); ++ if (0 == op) return 0; + # ifdef MERGE_SIZES + lw = GC_size_map[lb]; /* May have been uninitialized. */ + # endif +diff -urNb boehm-gc/version.h boehm-gc/version.h +--- boehm-gc/version.h Mon Feb 11 20:37:53 2002 ++++ boehm-gc/version.h Mon May 26 12:48:52 2003 +@@ -1,8 +1,25 @@ +-#define GC_VERSION_MAJOR 6 +-#define GC_VERSION_MINOR 1 +-#define GC_ALPHA_VERSION 3 ++/* The version here should match that in configure/configure.in */ ++/* Eventually this one may become unnecessary. For now we need */ ++/* it to keep the old-style build process working. */ ++#define GC_TMP_VERSION_MAJOR 6 ++#define GC_TMP_VERSION_MINOR 2 ++#define GC_TMP_ALPHA_VERSION 5 + ++#if defined(GC_VERSION_MAJOR) ++# if GC_TMP_VERSION_MAJOR != GC_VERSION_MAJOR || \ ++ GC_TMP_VERSION_MINOR != GC_VERSION_MINOR || \ ++ GC_TMP_ALPHA_VERSION != GC_ALPHA_VERSION ++# error Inconsistent version info. Check version.h and configure.in. ++# endif ++#else ++# define GC_VERSION_MAJOR GC_TMP_VERSION_MAJOR ++# define GC_VERSION_MINOR GC_TMP_VERSION_MINOR ++# define GC_ALPHA_VERSION GC_TMP_ALPHA_VERSION ++#endif ++ ++#ifndef GC_NOT_ALPHA + # define GC_NOT_ALPHA 0xff ++#endif + + #ifndef GC_NO_VERSION_VAR + +diff -urNb boehm-gc/win32_threads.c boehm-gc/win32_threads.c +--- boehm-gc/win32_threads.c Mon Apr 28 13:55:07 2003 ++++ boehm-gc/win32_threads.c Mon May 26 12:48:52 2003 +@@ -2,12 +2,26 @@ + + #include "private/gc_priv.h" + +-#if 0 +-#define STRICT +-#include ++#ifdef CYGWIN32 ++# include ++ ++ /* Cygwin-specific forward decls */ ++# undef pthread_create ++# undef pthread_sigmask ++# undef pthread_join ++# undef dlopen ++ ++# define DEBUG_CYGWIN_THREADS 0 ++ ++ GC_bool GC_thr_initialized = FALSE; ++ void * GC_start_routine(void * arg); ++ void GC_thread_exit_proc(void *arg); ++ + #endif + +-#define MAX_THREADS 64 ++#ifndef MAX_THREADS ++# define MAX_THREADS 64 ++#endif + + struct thread_entry { + LONG in_use; +@@ -18,6 +32,12 @@ + /* !in_use ==> stack == 0 */ + CONTEXT context; + GC_bool suspended; ++ ++# ifdef CYGWIN32 ++ void *status; /* hold exit value until join in case it's a pointer */ ++ pthread_t pthread_id; ++# endif ++ + }; + + volatile GC_bool GC_please_stop = FALSE; +@@ -29,6 +49,12 @@ + /* Unlike the other threads implementations, the thread table here */ + /* contains no pointers to the collectable heap. Thus we have */ + /* no private structures we need to preserve. */ ++# ifdef CYGWIN32 ++ { int i; /* pthreads may keep a pointer in the thread exit value */ ++ for (i = 0; i < MAX_THREADS; i++) ++ if (thread_table[i].in_use) GC_push_all((ptr_t)&(thread_table[i].status),(ptr_t)(&(thread_table[i].status)+1)); ++ } ++# endif + } + + void GC_stop_world() +@@ -36,6 +62,10 @@ + DWORD thread_id = GetCurrentThreadId(); + int i; + ++#ifdef CYGWIN32 ++ if (!GC_thr_initialized) ABORT("GC_stop_world() called before GC_thr_init()"); ++#endif ++ + GC_please_stop = TRUE; + for (i = 0; i < MAX_THREADS; i++) + if (thread_table[i].stack != 0 +@@ -53,10 +83,14 @@ + DWORD exitCode; + if (GetExitCodeThread(thread_table[i].handle,&exitCode) && + exitCode != STILL_ACTIVE) { +- thread_table[i].stack = 0; ++ thread_table[i].stack = 0; /* prevent stack from being pushed */ ++# ifndef CYGWIN32 ++ /* this breaks pthread_join on Cygwin, which is guaranteed to */ ++ /* only see user pthreads */ + thread_table[i].in_use = FALSE; + CloseHandle(thread_table[i].handle); + BZERO((void *)(&thread_table[i].context), sizeof(CONTEXT)); ++# endif + continue; + } + if (SuspendThread(thread_table[i].handle) == (DWORD)-1) +@@ -335,9 +369,11 @@ + if (*lo < start) *lo = start; + } + +-#if !defined(MSWINCE) && !(defined(__MINGW32__) && !defined(_DLL)) ++#if !defined(MSWINCE) && defined(GC_DLL) + +-HANDLE WINAPI GC_CreateThread( ++/* We register threads from DllMain */ ++ ++GC_API HANDLE GC_CreateThread( + LPSECURITY_ATTRIBUTES lpThreadAttributes, + DWORD dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, + LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId ) +@@ -346,7 +382,10 @@ + lpParameter, dwCreationFlags, lpThreadId); + } + +-#else /* !defined(MSWINCE) && !(defined(__MINGW32__) && !defined(_DLL)) */ ++#else /* defined(MSWINCE) || !defined(GC_DLL)) */ ++ ++/* We have no DllMain to take care of new threads. Thus we */ ++/* must properly intercept thread creation. */ + + typedef struct { + HANDLE child_ready_h, parent_ready_h; +@@ -527,22 +566,11 @@ + + LONG WINAPI GC_write_fault_handler(struct _EXCEPTION_POINTERS *exc_info); + +-#ifdef GC_DLL +- +-/* +- * This isn't generally safe, since DllMain is not premptible. +- * If another thread holds the lock while this runs we're in trouble. +- * Pontus Rydin suggests wrapping the thread start routine instead. ++/* threadAttach/threadDetach routines used by both CYGWIN and DLL ++ * implementation, since both recieve explicit notification on thread ++ * creation/destruction. + */ +-BOOL WINAPI DllMain(HINSTANCE inst, ULONG reason, LPVOID reserved) +-{ +- switch (reason) { +- case DLL_PROCESS_ATTACH: +- InitializeCriticalSection(&GC_allocate_ml); +- GC_init(); /* Force initialization before thread attach. */ +- /* fall through */ +- case DLL_THREAD_ATTACH: +- { ++static void threadAttach() { + int i; + /* It appears to be unsafe to acquire a lock here, since this */ + /* code is apparently not preeemptible on some systems. */ +@@ -554,14 +582,11 @@ + /* The following should be a noop according to the win32 */ + /* documentation. There is empirical evidence that it */ + /* isn't. - HB */ +-# ifdef MPROTECT_VDB ++# if defined(MPROTECT_VDB) + if (GC_incremental) SetUnhandledExceptionFilter(GC_write_fault_handler); + # endif +- +- for (i = 0; + /* cast away volatile qualifier */ +- InterlockedExchange((LPLONG) &thread_table[i].in_use, 1) != 0; +- i++) { ++ for (i = 0; InterlockedExchange((LONG*)&thread_table[i].in_use,1) != 0; i++) { + /* Compare-and-swap would make this cleaner, but that's not */ + /* supported before Windows 98 and NT 4.0. In Windows 2000, */ + /* InterlockedExchange is supposed to be replaced by */ +@@ -571,11 +596,13 @@ + ABORT("too many threads"); + } + thread_table[i].id = GetCurrentThreadId(); ++# ifdef CYGWIN32 ++ thread_table[i].pthread_id = pthread_self(); ++# endif + if (!DuplicateHandle(GetCurrentProcess(), + GetCurrentThread(), + GetCurrentProcess(), +- /* cast away volatile qualifier */ +- (HANDLE *) &thread_table[i].handle, ++ (HANDLE*)&thread_table[i].handle, + 0, + 0, + DUPLICATE_SAME_ACCESS)) { +@@ -584,33 +611,226 @@ + ABORT("DuplicateHandle failed"); + } + thread_table[i].stack = GC_get_stack_base(); ++ if (thread_table[i].stack == NULL) ++ ABORT("Failed to find stack base in threadAttach"); + /* If this thread is being created while we are trying to stop */ + /* the world, wait here. Hopefully this can't happen on any */ + /* systems that don't allow us to block here. */ + while (GC_please_stop) Sleep(20); +- } +- break; +- case DLL_THREAD_DETACH: +- { ++} ++ ++static void threadDetach(DWORD thread_id) { + int i; +- DWORD thread_id = GetCurrentThreadId(); ++ + LOCK(); + for (i = 0; + i < MAX_THREADS && +- (thread_table[i].stack == 0 || thread_table[i].id != thread_id); ++ !thread_table[i].in_use || thread_table[i].id != thread_id; + i++) {} +- if (i >= MAX_THREADS) { ++ if (i >= MAX_THREADS ) { + WARN("thread %ld not found on detach", (GC_word)thread_id); +- } else { ++ } ++ else { + thread_table[i].stack = 0; + thread_table[i].in_use = FALSE; + CloseHandle(thread_table[i].handle); + /* cast away volatile qualifier */ +- BZERO((void *) &thread_table[i].context, sizeof(CONTEXT)); ++ BZERO((void *)&thread_table[i].context, sizeof(CONTEXT)); ++ } ++ UNLOCK(); ++} ++ ++#ifdef CYGWIN32 ++ ++/* Called by GC_init() - we hold the allocation lock. */ ++void GC_thr_init() { ++ if (GC_thr_initialized) return; ++ GC_thr_initialized = TRUE; ++ ++#if 0 ++ /* this might already be handled in GC_init... */ ++ InitializeCriticalSection(&GC_allocate_ml); ++#endif ++ ++ /* Add the initial thread, so we can stop it. */ ++ threadAttach(); ++} ++ ++struct start_info { ++ void *(*start_routine)(void *); ++ void *arg; ++}; ++ ++int GC_pthread_join(pthread_t pthread_id, void **retval) { ++ int result; ++ int i; ++ ++# if DEBUG_CYGWIN_THREADS ++ GC_printf3("thread 0x%x(0x%x) is joining thread 0x%x.\n",(int)pthread_self(), ++ GetCurrentThreadId(), (int)pthread_id); ++# endif ++ ++ /* Can't do any table lookups here, because thread being joined ++ might not have registered itself yet */ ++ ++ result = pthread_join(pthread_id, retval); ++ ++ LOCK(); ++ for (i = 0; !thread_table[i].in_use || thread_table[i].pthread_id != pthread_id; ++ i++) { ++ if (i == MAX_THREADS - 1) { ++ GC_printf1("Failed to find thread 0x%x in pthread_join()\n", pthread_id); ++ ABORT("thread not found on detach"); ++ } + } + UNLOCK(); ++ threadDetach(thread_table[i].id); ++ ++# if DEBUG_CYGWIN_THREADS ++ GC_printf3("thread 0x%x(0x%x) completed join with thread 0x%x.\n", ++ (int)pthread_self(), GetCurrentThreadId(), (int)pthread_id); ++# endif ++ ++ return result; ++} ++ ++/* Cygwin-pthreads calls CreateThread internally, but it's not ++ * easily interceptible by us.. ++ * so intercept pthread_create instead ++ */ ++int ++GC_pthread_create(pthread_t *new_thread, ++ const pthread_attr_t *attr, ++ void *(*start_routine)(void *), void *arg) { ++ int result; ++ struct start_info * si; ++ ++ if (!GC_is_initialized) GC_init(); ++ /* make sure GC is initialized (i.e. main thread is attached) */ ++ ++ /* This is otherwise saved only in an area mmapped by the thread */ ++ /* library, which isn't visible to the collector. */ ++ si = GC_malloc_uncollectable(sizeof(struct start_info)); ++ if (0 == si) return(EAGAIN); ++ ++ si -> start_routine = start_routine; ++ si -> arg = arg; ++ ++# if DEBUG_CYGWIN_THREADS ++ GC_printf2("About to create a thread from 0x%x(0x%x)\n",(int)pthread_self(), ++ GetCurrentThreadId); ++# endif ++ result = pthread_create(new_thread, attr, GC_start_routine, si); ++ ++ if (result) { /* failure */ ++ GC_free(si); ++ } ++ ++ return(result); ++} ++ ++void * GC_start_routine(void * arg) ++{ ++ struct start_info * si = arg; ++ void * result; ++ void *(*start)(void *); ++ void *start_arg; ++ pthread_t pthread_id; ++ int i; ++ ++# if DEBUG_CYGWIN_THREADS ++ GC_printf2("thread 0x%x(0x%x) starting...\n",(int)pthread_self(), ++ GetCurrentThreadId()); ++# endif ++ ++ /* If a GC occurs before the thread is registered, that GC will */ ++ /* ignore this thread. That's fine, since it will block trying to */ ++ /* acquire the allocation lock, and won't yet hold interesting */ ++ /* pointers. */ ++ LOCK(); ++ /* We register the thread here instead of in the parent, so that */ ++ /* we don't need to hold the allocation lock during pthread_create. */ ++ threadAttach(); ++ UNLOCK(); ++ ++ start = si -> start_routine; ++ start_arg = si -> arg; ++ pthread_id = pthread_self(); ++ ++ GC_free(si); /* was allocated uncollectable */ ++ ++ pthread_cleanup_push(GC_thread_exit_proc, pthread_id); ++ result = (*start)(start_arg); ++ pthread_cleanup_pop(0); ++ ++# if DEBUG_CYGWIN_THREADS ++ GC_printf2("thread 0x%x(0x%x) returned from start routine.\n", ++ (int)pthread_self(),GetCurrentThreadId()); ++# endif ++ ++ LOCK(); ++ for (i = 0; thread_table[i].pthread_id != pthread_id; i++) { ++ if (i == MAX_THREADS - 1) ++ ABORT("thread not found on exit"); ++ } ++ thread_table[i].status = result; ++ UNLOCK(); ++ ++ return(result); ++} ++ ++void GC_thread_exit_proc(void *arg) ++{ ++ pthread_t pthread_id = (pthread_t)arg; ++ int i; ++ ++# if DEBUG_CYGWIN_THREADS ++ GC_printf2("thread 0x%x(0x%x) called pthread_exit().\n", ++ (int)pthread_self(),GetCurrentThreadId()); ++# endif ++ ++ LOCK(); ++ for (i = 0; thread_table[i].pthread_id != pthread_id; i++) { ++ if (i == MAX_THREADS - 1) ++ ABORT("thread not found on exit"); + } ++ UNLOCK(); ++ ++#if 0 ++ /* TODO: we need a way to get the exit value after a pthread_exit so we can stash it safely away */ ++ thread_table[i].status = ??? ++#endif ++} ++ ++/* nothing required here... */ ++int GC_pthread_sigmask(int how, const sigset_t *set, sigset_t *oset) { ++ return pthread_sigmask(how, set, oset); ++} ++int GC_pthread_detach(pthread_t thread) { ++ return pthread_detach(thread); ++} ++#else /* !CYGWIN32 */ ++ ++/* ++ * We avoid acquiring locks here, since this doesn't seem to be preemptable. ++ * Pontus Rydin suggests wrapping the thread start routine instead. ++ */ ++#ifdef GC_DLL ++BOOL WINAPI DllMain(HINSTANCE inst, ULONG reason, LPVOID reserved) ++{ ++ switch (reason) { ++ case DLL_PROCESS_ATTACH: ++ InitializeCriticalSection(&GC_allocate_ml); ++ GC_init(); /* Force initialization before thread attach. */ ++ /* fall through */ ++ case DLL_THREAD_ATTACH: ++ threadAttach(); ++ break; ++ ++ case DLL_THREAD_DETACH: ++ threadDetach(GetCurrentThreadId()); + break; ++ + case DLL_PROCESS_DETACH: + { + int i; +@@ -636,8 +856,8 @@ + } + return TRUE; + } +- +-# endif /* GC_DLL */ ++#endif /* GC_DLL */ ++#endif /* !CYGWIN32 */ + + # endif /* !MSWINCE */ + +--- boehm-gc/dyn_load.c Thu Sep 11 21:57:10 2003 ++++ boehm-gc/dyn_load.c Thu Sep 11 22:27:30 2003 +@@ -284,7 +284,7 @@ + /* Defined in os_dep.c. */ + + char *GC_parse_map_entry(char *buf_ptr, word *start, word *end, +- char *prot_buf, unsigned int *maj_dev); ++ char *prot_buf, unsigned int *maj_dev); + word GC_apply_to_maps(word (*fn)(char *)); + /* From os_dep.c */ + +@@ -335,7 +335,7 @@ + if (start >= least_ha && end <= greatest_ha) continue; + GC_add_roots_inner((char *)start, (char *)end, TRUE); + } +- } ++ } + return 1; + } + +@@ -971,6 +971,7 @@ + + #ifdef DARWIN + ++#define __private_extern__ + #include + #include + -- 1.7.10.4