Context Navigation

configure.in@ 3365

Visit:

Last change on this file since 3365 was 605, checked in by bird, 22 years ago
binutils v2.14 - offical sources.
Property cvs2svn:cvs-rev set to `1.1.1.2` Property svn:eol-style set to `native` Property svn:executable set to ``*
File size: 68.0 KB

Line
1	# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998,
2	# 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
3	#
4	# This file is free software; you can redistribute it and/or modify it
5	# under the terms of the GNU General Public License as published by
6	# the Free Software Foundation; either version 2 of the License, or
7	# (at your option) any later version.
8	#
9	# This program is distributed in the hope that it will be useful, but
10	# WITHOUT ANY WARRANTY; without even the implied warranty of
11	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12	# General Public License for more details.
13	#
14	# You should have received a copy of the GNU General Public License
15	# along with this program; if not, write to the Free Software
16	# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17
18	##############################################################################
19	### WARNING: this file contains embedded tabs. Do not run untabify on this file.
20
21	AC_INIT(move-if-change)
22	AC_PREREQ(2.13)
23	AC_CANONICAL_SYSTEM
24	AC_ARG_PROGRAM
25
26	sinclude(config/acx.m4)
27
28	### we might need to use some other shell than /bin/sh for running subshells
29	### If we are on Windows, search for the shell. This will permit people
30	### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
31	### without also having to set CONFIG_SHELL. This code will work when
32	### using bash, which sets OSTYPE.
33	case "${OSTYPE}" in
34	win32)
35	if test x${CONFIG_SHELL} = x ; then
36	if test ! -f /bin/sh ; then
37	if test x${SHELL} != x && test -f ${SHELL} ; then
38	CONFIG_SHELL=${SHELL}
39	export CONFIG_SHELL
40	else
41	for prog in sh sh.exe bash bash.exe; do
42	IFS="${IFS= }"; save_ifs="$IFS"; IFS="${IFS}:"
43	for dir in $PATH; do
44	test -z "$dir" && dir=.
45	if test -f $dir/$prog; then
46	CONFIG_SHELL=$dir/$prog
47	export CONFIG_SHELL
48	break
49	fi
50	done
51	IFS="$save_ifs"
52	test -n "${CONFIG_SHELL}" && break
53	done
54	fi
55	fi
56	fi
57	;;
58	esac
59
60	config_shell=${CONFIG_SHELL-/bin/sh}
61
62	progname=$0
63	# if PWD already has a value, it is probably wrong.
64	if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
65
66	# Export original configure arguments for use by sub-configures.
67	TOPLEVEL_CONFIGURE_ARGUMENTS="$progname $@"
68	AC_SUBST(TOPLEVEL_CONFIGURE_ARGUMENTS)
69
70	moveifchange=${srcdir}/move-if-change
71
72	# Set srcdir to "." if that's what it is.
73	# This is important for multilib support.
74	pwd=`${PWDCMD-pwd}`
75	srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
76	if test "${pwd}" = "${srcpwd}" ; then
77	srcdir=.
78	fi
79
80	topsrcdir=$srcpwd
81
82	extra_host_args=
83	# Define the trigger file to make sure configure will re-run whenever
84	# the gcc version number changes.
85	if test "${with_gcc_version_trigger+set}" = set ; then
86	gcc_version_trigger="$with_gcc_version_trigger"
87	gcc_version=`grep version_string ${with_gcc_version_trigger} \| sed -e 's/.\"$[[^ \"]]$[[ \"]].*/\1/'`
88	else
89	# If gcc's sources are available, define the trigger file.
90	if test -f ${topsrcdir}/gcc/version.c ; then
91	gcc_version_trigger=${topsrcdir}/gcc/version.c
92	gcc_version=`grep version_string ${gcc_version_trigger} \| sed -e 's/.\"$[[^ \"]]$[[ \"]].*/\1/'`
93	case "$ac_configure_args" in
94	--with-gcc-version-trigger=$gcc_version_trigger )
95	;;
96	* )
97	# Add to all subconfigure arguments: build, host, and target.
98	ac_configure_args="$ac_configure_args --with-gcc-version-trigger=$gcc_version_trigger"
99	;;
100	esac
101	fi
102	fi
103
104	### To add a new directory to the tree, first choose whether it is a target
105	### or a host dependent tool. Then put it into the appropriate list
106	### (library or tools, host or target), doing a dependency sort.
107
108	# Subdirs will be configured in the order listed in build_configdirs,
109	# configdirs, or target_configdirs; see the serialization section below.
110
111	# Dependency sorting is only needed when configuration must be done in
112	# a particular order. In all cases a dependency should be specified in
113	# the Makefile, whether or not it's implicitly specified here.
114
115	# Double entries in build_configdirs, configdirs, or target_configdirs may
116	# cause circular dependencies and break everything horribly.
117
118	# these libraries are used by various programs built for the host environment
119	#
120	host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl tix libgui zlib"
121
122	# these tools are built for the host environment
123	# Note, the powerpc-eabi build depends on sim occurring before gdb in order to
124	# know that we are building the simulator.
125	# binutils, gas and ld appear in that order because it makes sense to run
126	# "make check" in that particular order.
127	host_tools="byacc flex bison binutils gas ld gcc sid sim gdb make patch prms send-pr gprof etc expect dejagnu ash bash bzip2 m4 autoconf automake libtool diff rcs fileutils shellutils time textutils wdiff find uudecode hello tar gzip indent recode release sed utils guile perl gawk findutils gettext zip fastjar"
128
129	# libgcj represents the runtime libraries only used by gcj.
130	libgcj="target-libffi \
131	target-boehm-gc \
132	target-zlib \
133	target-qthreads \
134	target-libjava"
135
136	# these libraries are built for the target environment, and are built after
137	# the host libraries and the host tools (which may be a cross compiler)
138	#
139	target_libs="target-libiberty \
140	target-libgloss \
141	target-newlib \
142	target-libstdc++-v3 \
143	target-libf2c \
144	${libgcj} \
145	target-libobjc"
146
147	# these tools are built using the target libs, and are intended to run only
148	# in the target environment
149	#
150	# note: any program that uses libraries that are in the "target_libs"
151	# list belongs in this list. those programs are also very likely
152	# candidates for the "native_only" list which follows
153	#
154	target_tools="target-examples target-groff target-gperf target-rda"
155
156	################################################################################
157
158	## All tools belong in one of the four categories, and are assigned above
159	## We assign ${configdirs} this way to remove all embedded newlines. This
160	## is important because configure will choke if they ever get through.
161	## ${configdirs} is directories we build using the host tools.
162	## ${target_configdirs} is directories we build using the target tools.
163	#
164	configdirs=`echo ${host_libs} ${host_tools}`
165	target_configdirs=`echo ${target_libs} ${target_tools}`
166
167	################################################################################
168
169	srcname="gnu development package"
170
171	# This gets set non-empty for some net releases of packages.
172	appdirs=""
173
174	# Define is_cross_compiler to save on calls to 'test'.
175	is_cross_compiler=
176	if test x"${host}" = x"${target}" ; then
177	is_cross_compiler=no
178	else
179	is_cross_compiler=yes
180	fi
181
182	# We always want to use the same name for this directory, so that dejagnu
183	# can reliably find it.
184	target_subdir=${target_alias}
185
186	if test ! -d ${target_subdir} ; then
187	if mkdir ${target_subdir} ; then true
188	else
189	echo "'*** could not make ${PWD=`${PWDCMD-pwd}`}/${target_subdir}" 1>&2
190	exit 1
191	fi
192	fi
193
194	build_prefix=build-
195	build_subdir=${build_prefix}${build_alias}
196
197	if test x"${build_alias}" != x"${host}" ; then
198	if test ! -d ${build_subdir} ; then
199	if mkdir ${build_subdir} ; then true
200	else
201	echo "'*** could not make ${PWD=`${PWDCMD-pwd}`}/${build_subdir}" 1>&2
202	exit 1
203	fi
204	fi
205	fi
206
207	# Skipdirs are removed silently.
208	skipdirs=
209	# Noconfigdirs are removed loudly.
210	noconfigdirs=""
211
212	use_gnu_ld=
213	# Make sure we don't let GNU ld be added if we didn't want it.
214	if test x$with_gnu_ld = xno ; then
215	use_gnu_ld=no
216	noconfigdirs="$noconfigdirs ld"
217	fi
218
219	use_gnu_as=
220	# Make sure we don't let GNU as be added if we didn't want it.
221	if test x$with_gnu_as = xno ; then
222	use_gnu_as=no
223	noconfigdirs="$noconfigdirs gas"
224	fi
225
226	# some tools are so dependent upon X11 that if we're not building with X,
227	# it's not even worth trying to configure, much less build, that tool.
228
229	case ${with_x} in
230	yes \| "") ;; # the default value for this tree is that X11 is available
231	no)
232	skipdirs="${skipdirs} tk tix itcl libgui"
233	# We won't be able to build gdbtk without X.
234	enable_gdbtk=no
235	;;
236	) echo "** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
237	esac
238
239	# Some tools are only suitable for building in a "native" situation.
240	# Remove these if host!=target.
241	native_only="autoconf automake libtool fileutils find gawk gettext gzip hello indent m4 rcs recode sed shellutils tar textutils uudecode wdiff gprof target-groff guile perl time ash bash bzip2 prms gnuserv target-gperf"
242
243	# Similarly, some are only suitable for cross toolchains.
244	# Remove these if host=target.
245	cross_only="target-libgloss target-newlib target-opcodes"
246
247	case $is_cross_compiler in
248	no) skipdirs="${skipdirs} ${cross_only}" ;;
249	yes) skipdirs="${skipdirs} ${native_only}" ;;
250	esac
251
252	# If both --with-headers and --with-libs are specified, default to
253	# --without-newlib.
254	if test x"${with_headers}" != x && test x"${with_libs}" != x ; then
255	if test x"${with_newlib}" = x ; then
256	with_newlib=no
257	fi
258	fi
259
260	# Recognize --with-newlib/--without-newlib.
261	case ${with_newlib} in
262	no) skipdirs="${skipdirs} target-newlib" ;;
263	yes) skipdirs=`echo " ${skipdirs} " \| sed -e 's/ target-newlib / /'` ;;
264	esac
265
266	# Configure extra directories which are host specific
267
268	case "${host}" in
269	-cygwin)
270	configdirs="$configdirs libtermcap" ;;
271	esac
272
273	# Remove more programs from consideration, based on the host or
274	# target this usually means that a port of the program doesn't
275	# exist yet.
276
277	case "${host}" in
278	hppa64--)
279	noconfigdirs="$noconfigdirs byacc"
280	;;
281	i[[3456]]86-*-vsta)
282	noconfigdirs="tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl tix gnuserv gettext"
283	;;
284	i[[3456]]86--go32 \| i[[3456]]86--msdosdjgpp)
285	noconfigdirs="tcl tk expect dejagnu send-pr uudecode guile itcl tix gnuserv libffi"
286	;;
287	i[[3456]]86--mingw32)
288	# noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl tix gnuserv"
289	noconfigdirs="expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool"
290	;;
291	i[[3456]]86--beos)
292	noconfigdirs="$noconfigdirs tk itcl tix libgui gdb"
293	;;
294	--cygwin*)
295	noconfigdirs="autoconf automake send-pr rcs guile perl"
296	;;
297	--netbsd*)
298	noconfigdirs="rcs"
299	;;
300	ppc--pe)
301	noconfigdirs="patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl tix gnuserv"
302	;;
303	powerpc--beos)
304	noconfigdirs="$noconfigdirs tk itcl tix libgui gdb dejagnu readline"
305	;;
306	--darwin*)
307	noconfigdirs="$noconfigdirs tk itcl tix libgui"
308	;;
309	esac
310
311	# Save it here so that, even in case of --enable-libgcj, if the Java
312	# front-end isn't enabled, we still get libgcj disabled.
313	libgcj_saved=$libgcj
314	case $enable_libgcj in
315	yes)
316	# If we reset it here, it won't get added to noconfigdirs in the
317	# target-specific build rules, so it will be forcibly enabled
318	# (unless the Java language itself isn't enabled).
319	libgcj=
320	;;
321	no)
322	# Make sure we get it printed in the list of not supported target libs.
323	noconfigdirs="$noconfigdirs ${libgcj}"
324	;;
325	esac
326
327	case "${target}" in
328	--chorusos)
329	noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
330	;;
331	--darwin*)
332	noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes gdb gprof"
333	noconfigdirs="$noconfigdirs target-libobjc ${libgcj}"
334	;;
335	--freebsd[[12]] \| --freebsd[[12]].* \| --freebsdaout)
336	noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
337	;;
338	--kaos*)
339	# Remove unsupported stuff on all kaOS configurations.
340	skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-libf2c target-librx"
341	skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
342	skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
343	noconfigdirs="$noconfigdirs target-libgloss"
344	;;
345	--netbsd*)
346	# Skip some stuff on all NetBSD configurations.
347	noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
348
349	# Skip some stuff that's unsupported on some NetBSD configurations.
350	case "${target}" in
351	i86--netbsdelf*) ;;
352	arm--netbsdelf*) ;;
353	*)
354	noconfigdirs="$noconfigdirs ${libgcj}"
355	;;
356	esac
357	;;
358	--netware)
359	noconfigdirs="$noconfigdirs target-libstdc++-v3 target-newlib target-libiberty target-libgloss ${libgcj}"
360	;;
361	--rtems*)
362	noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
363	case ${target} in
364	h8300--* \| h8500--)
365	noconfigdirs="$noconfigdirs target-libf2c"
366	;;
367	*) ;;
368	esac
369	;;
370	--vxworks*)
371	noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
372	;;
373	alpha-dec-osf)
374	# ld works, but does not support shared libraries.
375	# newlib is not 64 bit ready. I'm not sure about fileutils.
376	# gas doesn't generate exception information.
377	noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
378	;;
379	alpha--vms)
380	noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
381	;;
382	alpha--linux*)
383	# newlib is not 64 bit ready
384	noconfigdirs="$noconfigdirs target-newlib target-libgloss"
385	;;
386	alpha--freebsd*)
387	noconfigdirs="$noconfigdirs target-newlib target-libgloss"
388	;;
389	alpha--*)
390	# newlib is not 64 bit ready
391	noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
392	;;
393	sh--linux)
394	noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
395	;;
396	sh--pe\|mips--pe\|*arm-wince-pe)
397	noconfigdirs="$noconfigdirs ${libgcj}"
398	noconfigdirs="$noconfigdirs target-examples"
399	noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
400	noconfigdirs="$noconfigdirs tcl tix tk itcl libgui sim"
401	noconfigdirs="$noconfigdirs expect dejagnu"
402	# the C++ libraries don't build on top of CE's C libraries
403	noconfigdirs="$noconfigdirs target-libstdc++-v3"
404	noconfigdirs="$noconfigdirs target-newlib"
405	case "${host}" in
406	--cygwin*) ;; # keep gdb and readline
407	*) noconfigdirs="$noconfigdirs gdb readline"
408	;;
409	esac
410	;;
411	arc--)
412	noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
413	;;
414	arm--coff \| strongarm--coff \| xscale-*-coff)
415	noconfigdirs="$noconfigdirs ${libgcj}"
416	;;
417	arm--elf \| strongarm--elf \| xscale--elf)
418	noconfigdirs="$noconfigdirs target-libffi target-qthreads"
419	;;
420	arm--pe)
421	noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
422	;;
423	arm--oabi)
424	noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
425	;;
426	thumb-*-coff)
427	noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
428	;;
429	thumb-*-elf)
430	noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
431	;;
432	thumb-*-oabi)
433	noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
434	;;
435	thumb-*-pe)
436	noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
437	;;
438	arm--riscix)
439	noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
440	;;
441	avr--)
442	noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
443	;;
444	c4x-- \| tic4x--)
445	noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
446	;;
447	c54x--* \| tic54x--)
448	noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
449	;;
450	cris--)
451	noconfigdirs="$noconfigdirs ${libgcj}"
452	;;
453	d10v--)
454	noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
455	;;
456	d30v--)
457	noconfigdirs="$noconfigdirs ${libgcj}"
458	;;
459	fr30--elf)
460	noconfigdirs="$noconfigdirs ${libgcj}"
461	;;
462	frv--)
463	noconfigdirs="$noconfigdirs ${libgcj}"
464	;;
465	h8300--*)
466	noconfigdirs="$noconfigdirs target-libgloss"
467	;;
468	h8500--)
469	noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} target-libf2c"
470	;;
471	hppa64--linux \| parisc64--linux)
472	# In this case, it's because the hppa64-linux target is for
473	# the kernel only at this point and has no libc, and thus no
474	# headers, crt*.o, etc., all of which are needed by these.
475	noconfigdirs="$noconfigdirs target-zlib"
476	;;
477	hppa--elf \| \
478	parisc--linux* \| hppa--linux* \| \
479	hppa--lites* \| \
480	hppa--openbsd* \| \
481	hppa64--)
482	noconfigdirs="$noconfigdirs ${libgcj}"
483	# Do configure ld/binutils/gas for this case.
484	;;
485	hppa--*)
486	# According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
487	# build on HP-UX 10.20.
488	noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
489	;;
490	ia64--elf*)
491	# No gdb support yet.
492	noconfigdirs="$noconfigdirs tix readline mmalloc libgui itcl gdb"
493	;;
494	ia64--hpux)
495	# No gdb or ld support yet.
496	noconfigdirs="$noconfigdirs tix readline mmalloc libgui itcl gdb ld"
497	;;
498	i[[3456]]86--coff \| i[[3456]]86--elf)
499	noconfigdirs="$noconfigdirs ${libgcj}"
500	;;
501	i[[34567]]86--freebsd)
502	noconfigdirs="$noconfigdirs target-newlib target-libgloss"
503	;;
504	i[[3456]]86--linux)
505	# The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
506	# not build java stuff by default.
507	case "${target}" in
508	--libc1)
509	noconfigdirs="$noconfigdirs ${libgcj}";;
510	esac
511
512	# This section makes it possible to build newlib natively on linux.
513	# If we are using a cross compiler then don't configure newlib.
514	if test x${is_cross_compiler} != xno ; then
515	noconfigdirs="$noconfigdirs target-newlib"
516	fi
517	noconfigdirs="$noconfigdirs target-libgloss"
518	# If we are not using a cross compiler, do configure newlib.
519	# Note however, that newlib will only be configured in this situation
520	# if the --with-newlib option has been given, because otherwise
521	# 'target-newlib' will appear in skipdirs.
522	;;
523	i[[3456]]86--mingw32)
524	target_configdirs="$target_configdirs target-mingw"
525	noconfigdirs="$noconfigdirs expect target-libgloss ${libgcj}"
526
527	# Can't build gdb for mingw32 if not native.
528	case "${host}" in
529	i[[3456]]86-*-mingw32) ;; # keep gdb tcl tk expect etc.
530	*) noconfigdirs="$noconfigdirs gdb tcl tk expect itcl tix gnuserv"
531	;;
532	esac
533	;;
534	--cygwin*)
535	target_configdirs="$target_configdirs target-libtermcap target-winsup"
536	noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
537	# always build newlib.
538	skipdirs=`echo " ${skipdirs} " \| sed -e 's/ target-newlib / /'`
539
540	# Can't build gdb for Cygwin if not native.
541	case "${host}" in
542	--cygwin*) ;; # keep gdb tcl tk expect etc.
543	*) noconfigdirs="$noconfigdirs gdb tcl tk expect itcl tix libgui gnuserv"
544	;;
545	esac
546	;;
547	i[[3456]]86-*-pe)
548	noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
549	;;
550	i[[3456]]86--sco3.2v5)
551	# The linker does not yet know about weak symbols in COFF,
552	# and is not configured to handle mixed ELF and COFF.
553	noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
554	;;
555	i[[3456]]86--sco)
556	noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
557	;;
558	i[[3456]]86--solaris2)
559	noconfigdirs="$noconfigdirs target-libgloss"
560	;;
561	i[[3456]]86--sysv4)
562	noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
563	;;
564	i[[3456]]86--beos)
565	noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
566	;;
567	m68hc11--\|m6811--\|m68hc12--\|m6812--)
568	noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
569	;;
570	m68k--elf)
571	noconfigdirs="$noconfigdirs ${libgcj}"
572	;;
573	m68k--coff)
574	noconfigdirs="$noconfigdirs ${libgcj}"
575	;;
576	mcore--pe)
577	# The EPOC C++ environment does not support exceptions or rtti,
578	# and so building libstdc++-v3 tends not to always work.
579	noconfigdirs="$noconfigdirs target-libstdc++-v3"
580	;;
581	mmix--)
582	noconfigdirs="$noconfigdirs ${libgcj} gdb libgloss"
583	;;
584	mn10200--)
585	noconfigdirs="$noconfigdirs ${libgcj}"
586	;;
587	mn10300--)
588	noconfigdirs="$noconfigdirs ${libgcj}"
589	;;
590	powerpc--aix)
591	# copied from rs6000-- entry
592	noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
593	;;
594	powerpc--winnt* \| powerpc--pe* \| ppc--pe)
595	target_configdirs="$target_configdirs target-winsup"
596	noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl tix gnuserv ${libgcj}"
597	# always build newlib.
598	skipdirs=`echo " ${skipdirs} " \| sed -e 's/ target-newlib / /'`
599	;;
600	# This is temporary until we can link against shared libraries
601	powerpcle--solaris)
602	noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl tix gnuserv ${libgcj}"
603	;;
604	powerpc--beos)
605	noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
606	;;
607	powerpc-*-eabi)
608	noconfigdirs="$noconfigdirs ${libgcj}"
609	;;
610	rs6000--lynxos)
611	noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
612	;;
613	rs6000--aix)
614	noconfigdirs="$noconfigdirs gprof ${libgcj}"
615	;;
616	rs6000--)
617	noconfigdirs="$noconfigdirs gprof ${libgcj}"
618	;;
619	m68k-apollo-*)
620	noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
621	;;
622	mips--irix5*)
623	# The GNU linker does not support shared libraries.
624	noconfigdirs="$noconfigdirs ld gprof target-libgloss ${libgcj}"
625	;;
626	mips--irix6*)
627	# Linking libjava exceeds command-line length limits on at least
628	# IRIX 6.2, but not on IRIX 6.5.
629	# Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
630	# <oldham@codesourcery.com>
631	noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
632	;;
633	mips-dec-bsd)
634	noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
635	;;
636	mips--bsd*)
637	noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
638	;;
639	mipstx39--)
640	noconfigdirs="$noconfigdirs gprof ${libgcj}" # same as generic mips
641	;;
642	mips--linux*)
643	noconfigdirs="$noconfigdirs target-newlib target-libgloss"
644	;;
645	mips--*)
646	noconfigdirs="$noconfigdirs gprof ${libgcj}"
647	;;
648	romp--)
649	noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
650	;;
651	sh--)
652	case "${host}" in
653	i[[3456]]86-*-vsta) ;; # don't add gprof back in
654	i[[3456]]86--go32) ;; # don't add gprof back in
655	i[[3456]]86--msdosdjgpp) ;; # don't add gprof back in
656	*) skipdirs=`echo " ${skipdirs} " \| sed -e 's/ gprof / /'` ;;
657	esac
658	noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
659	;;
660	sh64--)
661	noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
662	;;
663	sparc--elf)
664	noconfigdirs="$noconfigdirs ${libgcj}"
665	;;
666	sparc64--elf)
667	noconfigdirs="$noconfigdirs ${libgcj}"
668	;;
669	sparclite--)
670	noconfigdirs="$noconfigdirs ${libgcj}"
671	;;
672	sparc--sunos4)
673	noconfigdirs="$noconfigdirs ${libgcj}"
674	if test x${is_cross_compiler} != xno ; then
675	noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
676	else
677	use_gnu_ld=no
678	fi
679	;;
680	sparc--solaris \| sparc64--solaris \| sparcv9--solaris)
681	;;
682	v810--)
683	noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
684	;;
685	v850--)
686	noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
687	;;
688	v850e--)
689	noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
690	;;
691	v850ea--)
692	noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
693	;;
694	vax-*-vms)
695	noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
696	;;
697	vax--)
698	noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
699	;;
700	ip2k--)
701	noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
702	;;
703	--linux*)
704	noconfigdirs="$noconfigdirs target-newlib target-libgloss"
705	;;
706	--lynxos*)
707	noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
708	;;
709	--*)
710	noconfigdirs="$noconfigdirs ${libgcj}"
711	;;
712	esac
713
714	# If we aren't building newlib, then don't build libgloss, since libgloss
715	# depends upon some newlib header files.
716	case "${noconfigdirs}" in
717	target-libgloss) ;;
718	target-newlib) noconfigdirs="$noconfigdirs target-libgloss" ;;
719	esac
720
721	# Figure out what language subdirectories are present.
722	# Look if the user specified --enable-languages="..."; if not, use
723	# the environment variable $LANGUAGES if defined. $LANGUAGES might
724	# go away some day.
725	# NB: embedded tabs in this IF block -- do not untabify
726	if test x"${enable_languages+set}" != xset; then
727	if test x"${LANGUAGES+set}" = xset; then
728	enable_languages="${LANGUAGES}"
729	echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
730	else
731	enable_languages=all
732	fi
733	else
734	if test x"${enable_languages}" = x \|\|
735	test x"${enable_languages}" = xyes;
736	then
737	echo configure.in: --enable-languages needs at least one language argument 1>&2
738	exit 1
739	fi
740	fi
741	enable_languages=`echo "${enable_languages}" \| sed -e 's/[[ ,]][[ ,]]*/,/g' -e 's/,$//'`
742
743	# First scan to see if an enabled language requires some other language.
744	# We assume that a given config-lang.in will list all the language
745	# front ends it requires, even if some are required indirectly.
746	for lang in ${srcdir}/gcc/*/config-lang.in ..
747	do
748	case $lang in
749	..) ;;
750	# The odd quoting in the next line works around
751	# an apparent bug in bash 1.12 on linux.
752	${srcdir}/gcc/[[*]]/config-lang.in) ;;
753	*)
754	lang_alias=`sed -n -e 's,^language=[['"'"'"'"]]$.$[["'"'"'"']].$,\1,p' -e 's,^language=$[[^ ]]$.$,\1,p' $lang`
755	this_lang_requires=`sed -n -e 's,^lang_requires=[['"'"'"'"]]$.$[["'"'"'"']].$,\1,p' -e 's,^lang_requires=$[[^ ]]$.$,\1,p' $lang`
756	for other in $this_lang_requires
757	do
758	case ,${enable_languages}, in
759	,$other,) ;;
760	,all,) ;;
761	,$lang_alias,)
762	echo " \`$other' language required by \`$lang_alias'; enabling" 1>&2
763	enable_languages="$enable_languages,$other"
764	;;
765	esac
766	done
767	;;
768	esac
769	done
770
771	subdirs=
772	for lang in ${srcdir}/gcc/*/config-lang.in ..
773	do
774	case $lang in
775	..) ;;
776	# The odd quoting in the next line works around
777	# an apparent bug in bash 1.12 on linux.
778	${srcdir}/gcc/[[*]]/config-lang.in) ;;
779	*)
780	lang_alias=`sed -n -e 's,^language=[['"'"'"'"]]$.$[["'"'"'"']].$,\1,p' -e 's,^language=$[[^ ]]$.$,\1,p' $lang`
781	this_lang_libs=`sed -n -e 's,^target_libs=[['"'"'"'"]]$.$[["'"'"'"']].$,\1,p' -e 's,^target_libs=$[[^ ]]$.$,\1,p' $lang`
782	this_lang_dirs=`sed -n -e 's,^lang_dirs=[['"'"'"'"]]$.$[["'"'"'"']].$,\1,p' -e 's,^lang_dirs=$[[^ ]]$.$,\1,p' $lang`
783	build_by_default=`sed -n -e 's,^build_by_default=[['"'"'"'"]]$.$[["'"'"'"']].$,\1,p' -e 's,^build_by_default=$[[^ ]]$.$,\1,p' $lang`
784	if test "x$lang_alias" = x
785	then
786	echo "$lang doesn't set \$language." 1>&2
787	exit 1
788	fi
789	case ${build_by_default},${enable_languages}, in
790	,$lang_alias,) add_this_lang=yes ;;
791	no,*) add_this_lang=no ;;
792	,all,) add_this_lang=yes ;;
793	*) add_this_lang=no ;;
794	esac
795	if test x"${add_this_lang}" = xyes; then
796	eval target_libs='"$target_libs "'\"$this_lang_libs\"
797	else
798	eval noconfigdirs='"$noconfigdirs "'\"$this_lang_libs $this_lang_dirs\"
799	fi
800	;;
801	esac
802	done
803
804	# Remove the entries in $skipdirs and $noconfigdirs from $configdirs and
805	# $target_configdirs.
806	# If we have the source for $noconfigdirs entries, add them to $notsupp.
807
808	notsupp=""
809	for dir in . $skipdirs $noconfigdirs ; do
810	dirname=`echo $dir \| sed -e s/target-//g`
811	if test $dir != . && echo " ${configdirs} " \| grep " ${dir} " >/dev/null 2>&1; then
812	configdirs=`echo " ${configdirs} " \| sed -e "s/ ${dir} / /"`
813	if test -r $srcdir/$dirname/configure ; then
814	if echo " ${skipdirs} " \| grep " ${dir} " >/dev/null 2>&1; then
815	true
816	else
817	notsupp="$notsupp $dir"
818	fi
819	fi
820	fi
821	if test $dir != . && echo " ${target_configdirs} " \| grep " ${dir} " >/dev/null 2>&1; then
822	target_configdirs=`echo " ${target_configdirs} " \| sed -e "s/ ${dir} / /"`
823	if test -r $srcdir/$dirname/configure ; then
824	if echo " ${skipdirs} " \| grep " ${dir} " >/dev/null 2>&1; then
825	true
826	else
827	notsupp="$notsupp $dir"
828	fi
829	fi
830	fi
831	done
832
833	# Sometimes the tools are distributed with libiberty but with no other
834	# libraries. In that case, we don't want to build target-libiberty.
835	if test -n "${target_configdirs}" ; then
836	others=
837	for i in `echo ${target_configdirs} \| sed -e s/target-//g` ; do
838	if test "$i" != "libiberty" ; then
839	if test -r $srcdir/$i/configure ; then
840	others=yes;
841	break;
842	fi
843	fi
844	done
845	if test -z "${others}" ; then
846	target_configdirs=
847	fi
848	fi
849
850	# Quietly strip out all directories which aren't configurable in this tree.
851	# This relies on all configurable subdirectories being autoconfiscated, which
852	# is now the case.
853	configdirs_all="$configdirs"
854	configdirs=
855	for i in ${configdirs_all} ; do
856	if test -f ${srcdir}/$i/configure ; then
857	configdirs="${configdirs} $i"
858	fi
859	done
860	target_configdirs_all="$target_configdirs"
861	target_configdirs=
862	for i in ${target_configdirs_all} ; do
863	j=`echo $i \| sed -e s/target-//g`
864	if test -f ${srcdir}/$j/configure ; then
865	target_configdirs="${target_configdirs} $i"
866	fi
867	done
868
869	# Produce a warning message for the subdirs we can't configure.
870	# This isn't especially interesting in the Cygnus tree, but in the individual
871	# FSF releases, it's important to let people know when their machine isn't
872	# supported by the one or two programs in a package.
873
874	if test -n "${notsupp}" && test -z "${norecursion}" ; then
875	# If $appdirs is non-empty, at least one of those directories must still
876	# be configured, or we error out. (E.g., if the gas release supports a
877	# specified target in some subdirs but not the gas subdir, we shouldn't
878	# pretend that all is well.)
879	if test -n "$appdirs" ; then
880	for dir in $appdirs ; do
881	if test -r $dir/Makefile.in ; then
882	if echo " ${configdirs} " \| grep " ${dir} " >/dev/null 2>&1; then
883	appdirs=""
884	break
885	fi
886	if echo " ${target_configdirs} " \| grep " ${dir} " >/dev/null 2>&1; then
887	appdirs=""
888	break
889	fi
890	fi
891	done
892	if test -n "$appdirs" ; then
893	echo "*** This configuration is not supported by this package." 1>&2
894	exit 1
895	fi
896	fi
897	# Okay, some application will build, or we don't care to check. Still
898	# notify of subdirs not getting built.
899	echo "*** This configuration is not supported in the following subdirectories:" 1>&2
900	echo " ${notsupp}" 1>&2
901	echo " (Any other directories should still work fine.)" 1>&2
902	fi
903
904	case "$host" in
905	msdosdjgpp)
906	enable_gdbtk=no ;;
907	esac
908
909	copy_dirs=
910
911	# Handle --with-headers=XXX. If the value is not "yes", the contents of
912	# the named directory are copied to $(tooldir)/sys-include.
913	if test x"${with_headers}" != x ; then
914	if test x${is_cross_compiler} = xno ; then
915	echo 1>&2 '***' --with-headers is only supported when cross compiling
916	exit 1
917	fi
918	if test x"${with_headers}" != xyes ; then
919	case "${exec_prefixoption}" in
920	"") x=${prefix} ;;
921	*) x=${exec_prefix} ;;
922	esac
923	copy_dirs="${copy_dirs} ${with_headers} $x/${target_alias}/sys-include"
924	fi
925	fi
926
927	# Handle --with-libs=XXX. If the value is not "yes", the contents of
928	# the name directories are copied to $(tooldir)/lib. Multiple directories
929	# are permitted.
930	if test x"${with_libs}" != x ; then
931	if test x${is_cross_compiler} = xno ; then
932	echo 1>&2 '***' --with-libs is only supported when cross compiling
933	exit 1
934	fi
935	if test x"${with_libs}" != xyes ; then
936	# Copy the libraries in reverse order, so that files in the first named
937	# library override files in subsequent libraries.
938	case "${exec_prefixoption}" in
939	"") x=${prefix} ;;
940	*) x=${exec_prefix} ;;
941	esac
942	for l in ${with_libs}; do
943	copy_dirs="$l $x/${target_alias}/lib ${copy_dirs}"
944	done
945	fi
946	fi
947
948	# Handle ${copy_dirs}
949	set fnord ${copy_dirs}
950	shift
951	while test $# != 0 ; do
952	if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
953	:
954	else
955	echo Copying $1 to $2
956
957	# Use the install script to create the directory and all required
958	# parent directories.
959	if test -d $2 ; then
960	:
961	else
962	echo >config.temp
963	${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
964	fi
965
966	# Copy the directory, assuming we have tar.
967	# FIXME: Should we use B in the second tar? Not all systems support it.
968	(cd $1; tar -cf - .) \| (cd $2; tar -xpf -)
969
970	# It is the responsibility of the user to correctly adjust all
971	# symlinks. If somebody can figure out how to handle them correctly
972	# here, feel free to add the code.
973
974	echo $1 > $2/COPIED
975	fi
976	shift; shift
977	done
978
979	# Work in distributions that contain no compiler tools, like Autoconf.
980	tentative_cc=""
981	host_makefile_frag=/dev/null
982	if test -d ${srcdir}/config ; then
983	case "${host}" in
984	m68k-hp-hpux*)
985	# Avoid "too much defining" errors from HPUX compiler.
986	tentative_cc="cc -Wp,-H256000"
987	# If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
988	# If it's HP/UX ar, this should be harmless.
989	RANLIB="ar ts"
990	;;
991	m68k-apollo-sysv*)
992	tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
993	;;
994	m68k-apollo-bsd*)
995	#None of the Apollo compilers can compile gas or binutils. The preprocessor
996	# chokes on bfd, the compiler won't let you assign integers to enums, and
997	# other problems. Defining CC to gcc is a questionable way to say "don't use
998	# the apollo compiler" (the preferred version of GCC could be called cc,
999	# or whatever), but I'm not sure leaving CC as cc is any better...
1000	#CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
1001	# Used to have BISON=yacc.
1002	tentative_cc=gcc
1003	;;
1004	m88k-dg-dgux*)
1005	tentative_cc="gcc -Wall -ansi -D__using_DGUX"
1006	;;
1007	m88k-harris-cxux*)
1008	# Under CX/UX, we want to tell the compiler to use ANSI mode.
1009	tentative_cc="cc -Xa"
1010	host_makefile_frag="config/mh-cxux"
1011	;;
1012	m88k-motorola-sysv*)
1013	;;
1014	mips-dec-ultrix)
1015	tentative_cc="cc -Wf,-XNg1000"
1016	host_makefile_frag="config/mh-decstation"
1017	;;
1018	mips-nec-sysv4)
1019	# The C compiler on NEC MIPS SVR4 needs bigger tables.
1020	tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
1021	host_makefile_frag="config/mh-necv4"
1022	;;
1023	mips-sgi-irix4)
1024	# Tell compiler to use K&R C. We can't compile under the SGI Ansi
1025	# environment. Also bump switch table size so that cp-parse will
1026	# compile. Bump string length limit so linker builds.
1027	tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
1028	;;
1029	mips--sysv4*)
1030	host_makefile_frag="config/mh-sysv4"
1031	;;
1032	mips--sysv*)
1033	# This is for a MIPS running RISC/os 4.52C.
1034
1035	# This is needed for GDB, but needs to be in the top-level make because
1036	# if a library is compiled with the bsd headers and gets linked with the
1037	# sysv system libraries all hell can break loose (e.g. a jmp_buf might be
1038	# a different size).
1039	# ptrace(2) apparently has problems in the BSD environment. No workaround is
1040	# known except to select the sysv environment. Could we use /proc instead?
1041	# These "sysv environments" and "bsd environments" often end up being a pain.
1042	#
1043	# This is not part of CFLAGS because perhaps not all C compilers have this
1044	# option.
1045	tentative_cc="cc -systype sysv"
1046	;;
1047	i370-ibm-opened*)
1048	tentative_cc="c89"
1049	;;
1050	i[[3456]]86--sysv5)
1051	host_makefile_frag="config/mh-sysv5"
1052	;;
1053	i[[3456]]86--dgux)
1054	tentative_cc="gcc -Wall -ansi -D__using_DGUX"
1055	host_makefile_frag="config/mh-dgux386"
1056	;;
1057	i[[3456]]86-ncr-sysv4.3*)
1058	# The MetaWare compiler will generate a copyright message unless you
1059	# turn it off by adding the -Hnocopyr flag.
1060	tentative_cc="cc -Hnocopyr"
1061	;;
1062	i[[3456]]86-ncr-sysv4*)
1063	# for an NCR 3000 (i486/SVR4) system.
1064	# The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
1065	# This compiler not only emits obnoxious copyright messages every time
1066	# you run it, but it chokes and dies on a whole bunch of GNU source
1067	# files. Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
1068	tentative_cc="/usr/ccs/ATT/cc"
1069	host_makefile_frag="config/mh-ncr3000"
1070	;;
1071	i[[3456]]86--sco3.2v5)
1072	;;
1073	i[[3456]]86--sco)
1074	# The native C compiler botches some simple uses of const. Unfortunately,
1075	# it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
1076	tentative_cc="cc -Dconst="
1077	host_makefile_frag="config/mh-sco"
1078	;;
1079	i[[3456]]86--udk)
1080	host_makefile_frag="config/mh-sysv5"
1081	;;
1082	i[[3456]]86--solaris2)
1083	host_makefile_frag="config/mh-sysv4"
1084	;;
1085	i[[3456]]86--msdosdjgpp)
1086	host_makefile_frag="config/mh-djgpp"
1087	;;
1088	-cygwin)
1089	host_makefile_frag="config/mh-cygwin"
1090	;;
1091	-mingw32)
1092	host_makefile_frag="config/mh-mingw32"
1093	;;
1094	-interix)
1095	host_makefile_frag="config/mh-interix"
1096	;;
1097	vax--ultrix2)
1098	# The old BSD pcc isn't up to compiling parts of gdb so use gcc
1099	tentative_cc=gcc
1100	;;
1101	--solaris2*)
1102	host_makefile_frag="config/mh-solaris"
1103	;;
1104	m68k-sun-sunos*)
1105	# Sun's C compiler needs the -J flag to be able to compile cp-parse.c
1106	# without overflowing the jump tables (-J says to use a 32 bit table)
1107	tentative_cc="cc -J"
1108	;;
1109	-hp-hpux)
1110	tentative_cc="cc -Wp,-H256000"
1111	;;
1112	--hiux*)
1113	tentative_cc="cc -Wp,-H256000"
1114	;;
1115	rs6000--lynxos)
1116	# /bin/cc is less than useful for our purposes. Always use GCC
1117	tentative_cc="/usr/cygnus/progressive/bin/gcc"
1118	host_makefile_frag="config/mh-lynxrs6k"
1119	;;
1120	--lynxos*)
1121	# /bin/cc is less than useful for our purposes. Always use GCC
1122	tentative_cc="/bin/gcc"
1123	;;
1124	--sysv4*)
1125	host_makefile_frag="config/mh-sysv4"
1126	;;
1127	esac
1128	fi
1129
1130	extra_arflags_for_target=
1131	extra_nmflags_for_target=
1132	extra_ranlibflags_for_target=
1133	target_makefile_frag=/dev/null
1134	case "${target}" in
1135	i[[3456]]86--netware)
1136	target_makefile_frag="config/mt-netware"
1137	;;
1138	powerpc--netware)
1139	target_makefile_frag="config/mt-netware"
1140	;;
1141	--linux*)
1142	target_makefile_frag="config/mt-linux"
1143	;;
1144	--aix4.[[3456789]]* \| --aix[[56789]].*)
1145	# nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
1146	# commands to handle both 32-bit and 64-bit objects. These flags are
1147	# harmless if we're using GNU nm or ar.
1148	extra_arflags_for_target=" -X32_64"
1149	extra_nmflags_for_target=" -B -X32_64"
1150	;;
1151	--darwin*)
1152	# ranlib from Darwin requires the -c flag to look at common symbols.
1153	extra_ranlibflags_for_target=" -c"
1154	;;
1155	mips--pe \| sh--pe \| *arm-wince-pe)
1156	target_makefile_frag="config/mt-wince"
1157	;;
1158	esac
1159
1160	alphaieee_frag=/dev/null
1161	case $target in
1162	alpha--*)
1163	# This just makes sure to use the -mieee option to build target libs.
1164	# This should probably be set individually by each library.
1165	alphaieee_frag="config/mt-alphaieee"
1166	;;
1167	esac
1168
1169	# If --enable-target-optspace always use -Os instead of -O2 to build
1170	# the target libraries, similarly if it is not specified, use -Os
1171	# on selected platforms.
1172	ospace_frag=/dev/null
1173	case "${enable_target_optspace}:${target}" in
1174	yes:*)
1175	ospace_frag="config/mt-ospace"
1176	;;
1177	:d30v-*)
1178	ospace_frag="config/mt-d30v"
1179	;;
1180	:m32r-* \| :d10v-* \| :fr30-*)
1181	ospace_frag="config/mt-ospace"
1182	;;
1183	no:* \| :*)
1184	;;
1185	*)
1186	echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
1187	;;
1188	esac
1189
1190	# Set with_gnu_as and with_gnu_ld as appropriate.
1191	#
1192	# This is done by determining whether or not the appropriate directory
1193	# is available, and by checking whether or not specific configurations
1194	# have requested that this magic not happen.
1195	#
1196	# The command line options always override the explicit settings in
1197	# configure.in, and the settings in configure.in override this magic.
1198	#
1199	# If the default for a toolchain is to use GNU as and ld, and you don't
1200	# want to do that, then you should use the --without-gnu-as and
1201	# --without-gnu-ld options for the configure script.
1202
1203	if test x${use_gnu_as} = x &&
1204	echo " ${configdirs} " \| grep " gas " > /dev/null 2>&1 ; then
1205	with_gnu_as=yes
1206	extra_host_args="$extra_host_args --with-gnu-as"
1207	fi
1208
1209	if test x${use_gnu_ld} = x &&
1210	echo " ${configdirs} " \| grep " ld " > /dev/null 2>&1 ; then
1211	with_gnu_ld=yes
1212	extra_host_args="$extra_host_args --with-gnu-ld"
1213	fi
1214
1215	# If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
1216	# can detect this case.
1217
1218	if test x${with_newlib} != xno && echo " ${target_configdirs} " \| grep " target-newlib " > /dev/null 2>&1 ; then
1219	with_newlib=yes
1220	extra_host_args="$extra_host_args --with-newlib"
1221	fi
1222
1223
1224	# Default to using --with-stabs for certain targets.
1225	if test x${with_stabs} = x ; then
1226	case "${target}" in
1227	mips--irix6*o32)
1228	with_stabs=yes;
1229	extra_host_args="${extra_host_args} --with-stabs"
1230	;;
1231	mips--irix6*)
1232	;;
1233	mips--* \| alpha--osf*)
1234	with_stabs=yes;
1235	extra_host_args="${extra_host_args} --with-stabs"
1236	;;
1237	esac
1238	fi
1239
1240	# hpux11 in 64bit mode has libraries in a weird place. Arrange to find
1241	# them automatically.
1242	case "${host}" in
1243	hppa64--hpux11)
1244	extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
1245	;;
1246	esac
1247
1248	# If we aren't going to be using gcc, see if we can extract a definition
1249	# of CC from the fragment.
1250	# Actually, use the 'pre-extracted' version above.
1251	if test -z "${CC}" && test "${build}" = "${host}" ; then
1252	IFS="${IFS= }"; save_ifs="$IFS"; IFS="${IFS}:"
1253	found=
1254	for dir in $PATH; do
1255	test -z "$dir" && dir=.
1256	if test -f $dir/gcc; then
1257	found=yes
1258	break
1259	fi
1260	done
1261	IFS="$save_ifs"
1262	if test -z "${found}" && test -n "${tentative_cc}" ; then
1263	CC=$tentative_cc
1264	fi
1265	fi
1266
1267	# Some systems (e.g., one of the i386-aix systems the gas testers are
1268	# using) don't handle "\$" correctly, so don't use it here.
1269	tooldir='$(exec_prefix)'/${target_alias}
1270	build_tooldir=${tooldir}
1271
1272	# Generate a default definition for YACC. This is used if the makefile can't
1273	# locate bison or byacc in objdir.
1274
1275	for prog in 'bison -y' byacc yacc
1276	do
1277	set dummy $prog; tmp=$2
1278	IFS="${IFS= }"; save_ifs="$IFS"; IFS="${IFS}:"
1279	for dir in $PATH; do
1280	test -z "$dir" && dir=.
1281	if test -f $dir/$tmp; then
1282	DEFAULT_YACC="$prog"
1283	break
1284	fi
1285	done
1286	IFS="$save_ifs"
1287
1288	test -n "$DEFAULT_YACC" && break
1289	done
1290
1291	# Generate a default definition for M4. This is used if the makefile can't
1292	# locate m4 in objdir.
1293
1294	for prog in gm4 gnum4 m4
1295	do
1296	set dummy $prog; tmp=$2
1297	IFS="${IFS= }"; save_ifs="$IFS"; IFS="${IFS}:"
1298	for dir in $PATH; do
1299	test -z "$dir" && dir=.
1300	if test -f $dir/$tmp; then
1301	DEFAULT_M4="$prog"
1302	break
1303	fi
1304	done
1305	IFS="$save_ifs"
1306
1307	test -n "$DEFAULT_M4" && break
1308	done
1309
1310	# Generate a default definition for LEX. This is used if the makefile can't
1311	# locate flex in objdir.
1312
1313	for prog in flex lex
1314	do
1315	set dummy $prog; tmp=$2
1316	IFS="${IFS= }"; save_ifs="$IFS"; IFS="${IFS}:"
1317	for dir in $PATH; do
1318	test -z "$dir" && dir=.
1319	if test -f $dir/$tmp; then
1320	DEFAULT_LEX="$prog"
1321	break
1322	fi
1323	done
1324	IFS="$save_ifs"
1325
1326	test -n "$DEFAULT_LEX" && break
1327	done
1328
1329	if test "${build}" != "${host}" ; then
1330	# If we are doing a Canadian Cross, in which the host and build systems
1331	# are not the same, we set reasonable default values for the tools.
1332
1333	BISON=${BISON-bison}
1334	CC=${CC-${host_alias}-gcc}
1335	CFLAGS=${CFLAGS-"-g -O2"}
1336	CXX=${CXX-${host_alias}-c++}
1337	CXXFLAGS=${CXXFLAGS-"-g -O2"}
1338	CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
1339	CC_FOR_TARGET=${CC_FOR_TARGET-${target_alias}-gcc}
1340	CXX_FOR_TARGET=${CXX_FOR_TARGET-${target_alias}-c++}
1341	GCJ_FOR_TARGET=${GCJ_FOR_TARGET-${target_alias}-gcj}
1342	GCC_FOR_TARGET=${GCC_FOR_TARGET-${CC_FOR_TARGET-${target_alias}-gcc}}
1343	BUILD_PREFIX=${build_alias}-
1344	BUILD_PREFIX_1=${build_alias}-
1345	MAKEINFO=${MAKEINFO-makeinfo}
1346
1347	if test -z "${YACC}" ; then
1348	IFS="${IFS= }"; save_ifs="$IFS"; IFS="${IFS}:"
1349	for dir in $PATH; do
1350	test -z "$dir" && dir=.
1351	if test -f $dir/bison; then
1352	YACC="bison -y"
1353	break
1354	fi
1355	if test -f $dir/byacc; then
1356	YACC=byacc
1357	break
1358	fi
1359	if test -f $dir/yacc; then
1360	YACC=yacc
1361	break
1362	fi
1363	done
1364	IFS="$save_ifs"
1365	if test -z "${YACC}" ; then
1366	YACC="bison -y"
1367	fi
1368	fi
1369
1370	if test -z "${LEX}" ; then
1371	IFS="${IFS= }"; save_ifs="$IFS"; IFS="${IFS}:"
1372	for dir in $PATH; do
1373	test -z "$dir" && dir=.
1374	if test -f $dir/flex; then
1375	LEX=flex
1376	break
1377	fi
1378	if test -f $dir/lex; then
1379	LEX=lex
1380	break
1381	fi
1382	done
1383	IFS="$save_ifs"
1384	LEX=${LEX-flex}
1385	fi
1386
1387	else
1388	# Set reasonable default values for some tools even if not Canadian.
1389	# Of course, these are different reasonable default values, originally
1390	# specified directly in the Makefile.
1391	# We don't export, so that autoconf can do its job.
1392	# Note that all these settings are above the fragment inclusion point
1393	# in Makefile.in, so can still be overridden by fragments.
1394	# This is all going to change when we autoconfiscate...
1395
1396	BISON="\$(USUAL_BISON)"
1397	CC_FOR_BUILD="\$(CC)"
1398	GCC_FOR_TARGET="\$(USUAL_GCC_FOR_TARGET)"
1399	BUILD_PREFIX=
1400	BUILD_PREFIX_1=loser-
1401	MAKEINFO="\$(USUAL_MAKEINFO)"
1402	LEX="\$(USUAL_LEX)"
1403	YACC="\$(USUAL_YACC)"
1404
1405	# If CC is still not set, try to get gcc.
1406	cc_prog_is_gcc=
1407	if test -z "${CC}" ; then
1408	IFS="${IFS= }"; save_ifs="$IFS"; IFS="${IFS}:"
1409	for dir in $PATH; do
1410	test -z "$dir" && dir=.
1411	if test -f $dir/gcc; then
1412	CC="gcc"
1413	cc_prog_is_gcc=yes
1414	echo 'void f(){}' > conftest.c
1415	if test -z "`${CC} -g -c conftest.c 2>&1`"; then
1416	CFLAGS=${CFLAGS-"-g -O2"}
1417	CXXFLAGS=${CXXFLAGS-"-g -O2"}
1418	else
1419	CFLAGS=${CFLAGS-"-O2"}
1420	CXXFLAGS=${CXXFLAGS-"-O2"}
1421	fi
1422	rm -f conftest*
1423	break
1424	fi
1425	done
1426	IFS="$save_ifs"
1427	CC=${CC-cc}
1428	else
1429	# Determine if we are using gcc.
1430	cat > conftest.c <<EOF
1431	#ifdef __GNUC__
1432	yes;
1433	#endif
1434	EOF
1435	if ${CC} -E conftest.c \| grep yes >/dev/null 2>&1; then
1436	cc_prog_is_gcc=yes
1437	fi
1438	rm -f conftest.c
1439	if test -z "${CFLAGS}"; then
1440	# Here CC is set but CFLAGS is not. Use a quick hack to use -O2 if CC
1441	# is set to a version of gcc.
1442	if test "$cc_prog_is_gcc" = yes; then
1443	echo 'void f(){}' > conftest.c
1444	if test -z "`${CC} -g -c conftest.c 2>&1`"; then
1445	CFLAGS=${CFLAGS-"-g -O2"}
1446	CXXFLAGS=${CXXFLAGS-"-g -O2"}
1447	else
1448	CFLAGS=${CFLAGS-"-O2"}
1449	CXXFLAGS=${CXXFLAGS-"-O2"}
1450	fi
1451	rm -f conftest*
1452	fi
1453	fi
1454	fi
1455
1456	# We must set the default linker to the linker used by gcc for the correct
1457	# operation of libtool. If LD is not defined and we are using gcc, try to
1458	# set the LD default to the ld used by gcc.
1459	if test -z "$LD"; then
1460	if test "$cc_prog_is_gcc" = yes; then
1461	case $build in
1462	--mingw*)
1463	gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 \| tr -d '\015'` ;;
1464	*)
1465	gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
1466	esac
1467	case $gcc_prog_ld in
1468	# Accept absolute paths.
1469	[[\\/]* \| [A-Za-z]:[\\/]*)]
1470	LD="$gcc_prog_ld" ;;
1471	esac
1472	fi
1473	fi
1474
1475	CXX=${CXX-"c++"}
1476	CFLAGS=${CFLAGS-"-g"}
1477	CXXFLAGS=${CXXFLAGS-"-g -O2"}
1478	fi
1479
1480	# FIXME Should this be done recursively ??? (Useful for e.g. gdbtest)
1481	# Set up the list of links to be made.
1482	# ${links} is the list of link names, and ${files} is the list of names to link to.
1483
1484	# Make the links.
1485	configlinks="${links}"
1486	if test -r ./config.status ; then
1487	mv -f ./config.status ./config.back
1488	fi
1489	while test -n "${files}" ; do
1490	# set file to car of files, files to cdr of files
1491	set ${files}; file=$1; shift; files=$*
1492	set ${links}; link=$1; shift; links=$*
1493
1494	if test ! -r ${srcdir}/${file} ; then
1495	if test ! -r ${file} ; then
1496	echo '***' "${progname}: cannot create a link \"${link}\"," 1>&2
1497	echo '***' "since the file \"${srcdir}/${file}\" does not exist." 1>&2
1498	exit 1
1499	else
1500	srcfile=${file}
1501	fi
1502	else
1503	srcfile=${srcdir}/${file}
1504	fi
1505
1506	${remove} -f ${link}
1507	# Make a symlink if possible, otherwise try a hard link
1508	if ${symbolic_link} ${srcfile} ${link} >/dev/null 2>&1 ; then
1509	true
1510	else
1511	# We need to re-remove the file because Lynx leaves a
1512	# very strange directory there when it fails an NFS symlink.
1513	${remove} -r -f ${link}
1514	${hard_link} ${srcfile} ${link}
1515	fi
1516	if test ! -r ${link} ; then
1517	echo '***' "${progname}: unable to link \"${link}\" to \"${srcfile}\"." 1>&2
1518	exit 1
1519	fi
1520
1521	echo "Linked \"${link}\" to \"${srcfile}\"."
1522	done
1523
1524	# Create a .gdbinit file which runs the one in srcdir
1525	# and tells GDB to look there for source files.
1526
1527	if test -r ${srcdir}/.gdbinit ; then
1528	case ${srcdir} in
1529	.) ;;
1530	*) cat > ./.gdbinit <<EOF
1531	# ${NO_EDIT}
1532	dir ${srcdir}
1533	dir .
1534	source ${srcdir}/.gdbinit
1535	EOF
1536	;;
1537	esac
1538	fi
1539
1540	# Make sure that the compiler is able to generate an executable. If it
1541	# can't, we are probably in trouble. We don't care whether we can run the
1542	# executable--we might be using a cross compiler--we only care whether it
1543	# can be created. At this point the main configure script has set CC.
1544	we_are_ok=no
1545	echo "int main () { return 0; }" > conftest.c
1546	${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
1547	if test $? = 0 ; then
1548	if test -s conftest \|\| test -s conftest.exe ; then
1549	we_are_ok=yes
1550	fi
1551	fi
1552	case $we_are_ok in
1553	no)
1554	echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
1555	echo 1>&2 "*** You must set the environment variable CC to a working compiler."
1556	rm -f conftest*
1557	exit 1
1558	;;
1559	esac
1560	rm -f conftest*
1561
1562	# The Solaris /usr/ucb/cc compiler does not appear to work.
1563	case "${host}" in
1564	sparc-sun-solaris2*)
1565	CCBASE="`echo ${CC-cc} \| sed 's/ .*$//'`"
1566	if test "`type $CCBASE \| sed 's/^[[^/]]*//'`" = "/usr/ucb/cc" ; then
1567	could_use=
1568	test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
1569	if test -d /opt/cygnus/bin ; then
1570	if test "$could_use" = "" ; then
1571	could_use="/opt/cygnus/bin"
1572	else
1573	could_use="$could_use or /opt/cygnus/bin"
1574	fi
1575	fi
1576	if test "$could_use" = "" ; then
1577	echo "Warning: compilation may fail because you're using"
1578	echo "/usr/ucb/cc. You should change your PATH or CC "
1579	echo "variable and rerun configure."
1580	else
1581	echo "Warning: compilation may fail because you're using"
1582	echo "/usr/ucb/cc, when you should use the C compiler from"
1583	echo "$could_use. You should change your"
1584	echo "PATH or CC variable and rerun configure."
1585	fi
1586	fi
1587	;;
1588	esac
1589
1590	# If --enable-shared was set, we must set LD_LIBRARY_PATH so that the
1591	# binutils tools will find libbfd.so.
1592	case "${enable_shared}" in
1593	no \| "") SET_LIB_PATH= ;;
1594	*) SET_LIB_PATH="\$(REALLY_SET_LIB_PATH)" ;;
1595	esac
1596
1597	case "${host}" in
1598	--hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
1599	*) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
1600	esac
1601
1602	# Record target_configdirs and the configure arguments for target and
1603	# build configuration in Makefile.
1604	target_configdirs=`echo "${target_configdirs}" \| sed -e 's/target-//g'`
1605
1606	# This is the final value for target_configdirs. configdirs already
1607	# has its final value. It's time to create some lists of valid targets.
1608
1609	# While at that, we remove Makefiles if we were started for recursive
1610	# configuration, such that the top-level Makefile reconfigures them,
1611	# like we used to do when configure itself was recursive.
1612
1613	all_build_modules=
1614	configure_build_modules=
1615	# Only make build modules if build != host.
1616	# This should be done more generally, but at the moment it doesn't matter.
1617	if test ${host_alias} != ${build_alias} ; then
1618	for module in libiberty ; do
1619	all_build_modules=all-build-${module}
1620	configure_build_modules=configure-build-${module}
1621	if test -z "${no_recursion}" \
1622	&& test -f ${build_subdir}/${module}/Makefile; then
1623	echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
1624	rm -f ${build_subdir}/${module}/Makefile
1625	fi
1626	done
1627	fi
1628
1629	all_host_modules=
1630	check_host_modules=
1631	install_host_modules=
1632	configure_host_modules=
1633	for module in ${configdirs} ; do
1634	all_host_modules="${all_host_modules} all-${module}"
1635	check_host_modules="${check_host_modules} check-${module}"
1636	install_host_modules="${install_host_modules} install-${module}"
1637	configure_host_modules="${configure_host_modules} configure-${module}"
1638	if test -z "${no_recursion}" \
1639	&& test -f ${module}/Makefile; then
1640	echo 1>&2 "*** removing ${module}/Makefile to force reconfigure"
1641	rm -f ${module}/Makefile
1642	fi
1643	done
1644	install_host_modules_nogcc=`echo "${install_host_modules}" \| sed -e 's/install-gcc//g'`
1645
1646	all_target_modules=
1647	check_target_modules=
1648	install_target_modules=
1649	configure_target_modules=
1650	for module in ${target_configdirs} ; do
1651	all_target_modules="${all_target_modules} all-target-${module}"
1652	check_target_modules="${check_target_modules} check-target-${module}"
1653	install_target_modules="${install_target_modules} install-target-${module}"
1654	configure_target_modules="${configure_target_modules} configure-target-${module}"
1655	if test -z "${no_recursion}" \
1656	&& test -f ${target_subdir}/${module}/Makefile; then
1657	echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
1658	rm -f ${target_subdir}/${module}/Makefile
1659	fi
1660	done
1661
1662	# Determine whether gdb needs tk/tcl or not.
1663	# Use 'maybe' since enable_gdbtk might be true even if tk isn't available
1664	# and in that case we want gdb to be built without tk. Ugh!
1665	# In fact I believe gdb is the only package directly dependent on tk,
1666	# so we should be able to put the 'maybe's in unconditionally and
1667	# leave out the maybe dependencies when enable_gdbtk is false. I'm not
1668	# 100% sure that that's safe though.
1669
1670	gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-tix maybe-all-libgui"
1671	case "$enable_gdbtk" in
1672	no)
1673	GDB_TK="" ;;
1674	yes)
1675	GDB_TK="${gdb_tk}" ;;
1676	*)
1677	# Only add the dependency on gdbtk when GDBtk is part of the gdb
1678	# distro. Eventually someone will fix this and move Insight, nee
1679	# gdbtk to a separate directory.
1680	if test -d ${srcdir}/gdb/gdbtk ; then
1681	GDB_TK="${gdb_tk}"
1682	else
1683	GDB_TK=""
1684	fi
1685	;;
1686	esac
1687
1688	# Create the 'maybe dependencies'. This uses a temporary file.
1689	rm -f maybedep.tmp
1690	echo '# maybedep.tmp' > maybedep.tmp
1691	for item in ${all_build_modules} ${all_host_modules} ${all_target_modules} \
1692	${install_host_modules} ${install_target_modules} \
1693	${configure_build_modules} ${configure_host_modules} ${configure_target_modules} \
1694	; do
1695	echo "maybe-${item}: ${item}" >> maybedep.tmp
1696	done
1697	maybe_dependencies=maybedep.tmp
1698	AC_SUBST_FILE(maybe_dependencies)
1699
1700	# Create the serialization dependencies. This uses a temporary file.
1701
1702	AC_ARG_ENABLE([serial-configure],
1703	[ --disable-serial-[{host,target,build}-]configure
1704	Don't force sequential configuration of
1705	sub-packages for the host, target or build
1706	machine, or of any sub-packages at all])
1707
1708	# These force 'configure's to be done one at a time, to avoid problems
1709	# with contention over a shared config.cache.
1710	rm -f serdep.tmp
1711	echo '# serdep.tmp' > serdep.tmp
1712	olditem=
1713	test "x${enable_serial_configure}" = xno \|\|
1714	test "x${enable_serial_build_configure}" = xno \|\|
1715	for item in ${build_configdirs} ; do
1716	case ${olditem} in
1717	"") ;;
1718	*) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
1719	esac
1720	olditem=${item}
1721	done
1722	olditem=
1723	test "x${enable_serial_configure}" = xno \|\|
1724	test "x${enable_serial_host_configure}" = xno \|\|
1725	for item in ${configdirs} ; do
1726	case ${olditem} in
1727	"") ;;
1728	*) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
1729	esac
1730	olditem=${item}
1731	done
1732	olditem=
1733	test "x${enable_serial_configure}" = xno \|\|
1734	test "x${enable_serial_target_configure}" = xno \|\|
1735	for item in ${target_configdirs} ; do
1736	case ${olditem} in
1737	"") ;;
1738	*) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
1739	esac
1740	olditem=${item}
1741	done
1742	serialization_dependencies=serdep.tmp
1743	AC_SUBST_FILE(serialization_dependencies)
1744
1745	# Base args. Strip norecursion, cache-file, srcdir, host, build,
1746	# target and nonopt. These are the ones we might not want to pass
1747	# down to subconfigures.
1748	baseargs=`echo " ${ac_configure_args} " \| \
1749	sed -e 's/ --no[[^ ]]* / /' \
1750	-e 's/ --c[[a-z-]][[= ]][[^ ]] / /' \
1751	-e 's/ --sr[[a-z-]][[= ]][[^ ]] / /' \
1752	-e 's/ --ho[[a-z-]][[= ]][[^ ]] / /' \
1753	-e 's/ --bu[[a-z-]][[= ]][[^ ]] / /' \
1754	-e 's/ --t[[a-z-]][[= ]][[^ ]] / /' \
1755	-e 's/ -cache-file[[= ]][[^ ]]* / /' \
1756	-e 's/ -srcdir[[= ]][[^ ]]* / /' \
1757	-e 's/ -host[[= ]][[^ ]]* / /' \
1758	-e 's/ -build[[= ]][[^ ]]* / /' \
1759	-e 's/ -target[[= ]][[^ ]]* / /' \
1760	-e "s/ [[^' -][^ ]*] / /" \
1761	-e 's/^ //;s/ $//'`
1762
1763	# For the build-side libraries, we just need to pretend we're native,
1764	# and not use the same cache file. Multilibs are neither needed nor
1765	# desired.
1766	build_configargs="--cache-file=../config.cache --build=${build_alias} --host=${build_alias} ${baseargs}"
1767
1768	# For host modules, accept cache file option, or specification as blank.
1769	case "${cache_file}" in
1770	"") # empty
1771	cache_file_option="" ;;
1772	/* \| [[A-Za-z]]:[[\\/]]* ) # absolute path
1773	cache_file_option="--cache-file=${cache_file}" ;;
1774	*) # relative path
1775	cache_file_option="--cache-file=../${cache_file}" ;;
1776	esac
1777
1778	host_configargs="${cache_file_option} --build=${build_alias} --host=${host_alias} --target=${target_alias} ${extra_host_args} ${baseargs}"
1779
1780	target_configargs=${baseargs}
1781
1782	# Passing a --with-cross-host argument lets the target libraries know
1783	# whether they are being built with a cross-compiler or being built
1784	# native. However, it would be better to use other mechanisms to make the
1785	# sorts of decisions they want to make on this basis. Please consider
1786	# this option to be deprecated. FIXME.
1787	if test x${is_cross_compiler} = xyes ; then
1788	target_configargs="--with-cross-host=${host_alias} ${target_configargs}"
1789	fi
1790
1791	# Default to --enable-multilib.
1792	if test x${enable_multilib} = x ; then
1793	target_configargs="--enable-multilib ${target_configargs}"
1794	fi
1795
1796	# Pass --with-newlib if appropriate. Note that target_configdirs has
1797	# changed from the earlier setting of with_newlib.
1798	if test x${with_newlib} != xno && echo " ${target_configdirs} " \| grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
1799	target_configargs="--with-newlib ${target_configargs}"
1800	fi
1801
1802	# Pass the appropriate --host, --build, and --cache-file arguments.
1803	target_configargs="--cache-file=../config.cache --host=${target_alias} --build=${build_alias} ${target_configargs}"
1804
1805	# provide a proper gxx_include_dir.
1806	# Note, if you change the default, make sure to fix both here and in
1807	# the gcc and libstdc++-v3 subdirectories.
1808	# Check whether --with-gxx-include-dir or --without-gxx-include-dir was given.
1809	case "${with_gxx_include_dir}" in
1810	yes)
1811	AC_MSG_ERROR([--with-gxx-include-dir=[[dir]] requires a directory])
1812	;;
1813	no \| "")
1814	case "${enable_version_specific_runtime_libs}" in
1815	yes) gxx_include_dir='${libsubdir}/include/c++' ;;
1816	*)
1817	. ${srcdir}/config.if
1818	gxx_include_dir='${prefix}/include/'${libstdcxx_incdir} ;;
1819	esac ;;
1820	*) gxx_include_dir=${with_gxx_include_dir} ;;
1821	esac
1822
1823	FLAGS_FOR_TARGET=
1824	case " $target_configdirs " in
1825	" newlib ")
1826	case " $target_configargs " in
1827	" --with-newlib ")
1828	case "$target" in
1829	-cygwin)
1830	FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/winsup -L$$r/$(TARGET_SUBDIR)/winsup/cygwin -L$$r/$(TARGET_SUBDIR)/winsup/w32api/lib -isystem $$s/winsup/include -isystem $$s/winsup/cygwin/include -isystem $$s/winsup/w32api/include -isystem $$s/newlib/libc/sys/cygwin -isystem $$s/newlib/libc/sys/cygwin32' ;;
1831	esac
1832
1833	# If we're not building GCC, don't discard standard headers.
1834	if test -d ${srcdir}/gcc; then
1835	FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
1836
1837	if test "${build}" != "${host}"; then
1838	# On Canadian crosses, CC_FOR_TARGET will have already been set
1839	# by `configure', so we won't have an opportunity to add -Bgcc/
1840	# to it. This is right: we don't want to search that directory
1841	# for binaries, but we want the header files in there, so add
1842	# them explicitly.
1843	FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/gcc/include'
1844
1845	# Someone might think of using the pre-installed headers on
1846	# Canadian crosses, in case the installed compiler is not fully
1847	# compatible with the compiler being built. In this case, it
1848	# would be better to flag an error than risking having
1849	# incompatible object files being constructed. We can't
1850	# guarantee that an error will be flagged, but let's hope the
1851	# compiler will do it, when presented with incompatible header
1852	# files.
1853	fi
1854	fi
1855
1856	case "${target}-${is_cross_compiler}" in
1857	i[[3456]]86--linux-no)
1858	# Here host == target, so we don't need to build gcc,
1859	# so we don't want to discard standard headers.
1860	FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " \| sed -e 's/ -nostdinc / /'`
1861	;;
1862	*)
1863	# If we're building newlib, use its generic headers last, but search
1864	# for any libc-related directories first (so make it the last -B
1865	# switch).
1866	FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
1867	;;
1868	esac
1869	;;
1870	esac
1871	;;
1872	esac
1873
1874	# On Canadian crosses, we'll be searching the right directories for
1875	# the previously-installed cross compiler, so don't bother to add
1876	# flags for directories within the install tree of the compiler
1877	# being built; programs in there won't even run.
1878	if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
1879	# Search for pre-installed headers if nothing else fits.
1880	FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
1881	fi
1882
1883	if test "x${use_gnu_ld}" = x &&
1884	echo " ${configdirs} " \| grep " ld " > /dev/null ; then
1885	# Arrange for us to find uninstalled linker scripts.
1886	FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/ld'
1887	fi
1888
1889	if test "x${CC_FOR_TARGET+set}" = xset; then
1890	:
1891	elif test -d ${srcdir}/gcc; then
1892	CC_FOR_TARGET='$$r/gcc/xgcc -B$$r/gcc/'
1893	elif test "$host" = "$target"; then
1894	CC_FOR_TARGET='$(CC)'
1895	else
1896	CC_FOR_TARGET=`echo gcc \| sed "${program_transform_name}"`
1897	fi
1898	CC_FOR_TARGET=$CC_FOR_TARGET' $(FLAGS_FOR_TARGET)'
1899
1900	if test "x${GCJ_FOR_TARGET+set}" = xset; then
1901	:
1902	elif test -d ${srcdir}/gcc; then
1903	GCJ_FOR_TARGET='$$r/gcc/gcj -B$$r/gcc/'
1904	elif test "$host" = "$target"; then
1905	GCJ_FOR_TARGET='gcj'
1906	else
1907	GCJ_FOR_TARGET=`echo gcj \| sed "${program_transform_name}"`
1908	fi
1909	GCJ_FOR_TARGET=$GCJ_FOR_TARGET' $(FLAGS_FOR_TARGET)'
1910
1911	# Don't use libstdc++-v3's flags to configure/build itself.
1912	libstdcxx_flags='`test ! -f $$r/$(TARGET_SUBDIR)/libstdc++-v3/testsuite_flags \|\| $(SHELL) $$r/$(TARGET_SUBDIR)/libstdc++-v3/testsuite_flags --build-includes` -L$$r/$(TARGET_SUBDIR)/libstdc++-v3/src -L$$r/$(TARGET_SUBDIR)/libstdc++-v3/src/.libs'
1913	raw_libstdcxx_flags=' -L$$r/$(TARGET_SUBDIR)/libstdc++-v3/src -L$$r/$(TARGET_SUBDIR)/libstdc++-v3/src/.libs'
1914
1915	if test "x${CXX_FOR_TARGET+set}" = xset; then
1916	:
1917	elif test -d ${srcdir}/gcc; then
1918	# We add -shared-libgcc to CXX_FOR_TARGET whenever we use xgcc instead
1919	# of g++ for linking C++ or Java, because g++ has -shared-libgcc by
1920	# default whereas gcc does not.
1921	# RAW_CXX_FOR_TARGET is for linking C++ or java; CXX_FOR_TARGET is for
1922	# all other cases.
1923	CXX_FOR_TARGET='$$r/gcc/g++ -B$$r/gcc/ -nostdinc++ '$libstdcxx_flags
1924	RAW_CXX_FOR_TARGET='$$r/gcc/xgcc -shared-libgcc -B$$r/gcc/ -nostdinc++ '$raw_libstdcxx_flags
1925	elif test "$host" = "$target"; then
1926	CXX_FOR_TARGET='$(CXX)'
1927	RAW_CXX_FOR_TARGET=${CXX_FOR_TARGET}
1928	else
1929	CXX_FOR_TARGET=`echo c++ \| sed "${program_transform_name}"`
1930	RAW_CXX_FOR_TARGET=${CXX_FOR_TARGET}
1931	fi
1932	CXX_FOR_TARGET=$CXX_FOR_TARGET' $(FLAGS_FOR_TARGET)'
1933	RAW_CXX_FOR_TARGET=$RAW_CXX_FOR_TARGET' $(FLAGS_FOR_TARGET)'
1934
1935	qCXX_FOR_TARGET=`echo "$CXX_FOR_TARGET" \| sed 's,[[&%]],\\\&,g'`
1936	qRAW_CXX_FOR_TARGET=`echo "$RAW_CXX_FOR_TARGET" \| sed 's,[[&%]],\\\&,g'`
1937
1938	# We want to defer the evaluation of `cmd`s and shell variables in
1939	# CXX_FOR_TARGET when recursing in the top-level Makefile, such as for
1940	# bootstrap. We'll enclose CXX_FOR_TARGET_FOR_RECURSIVE_MAKE in single
1941	# quotes, but we still have to duplicate `$'s so that shell variables
1942	# can be expanded by the nested make as shell variables, not as make
1943	# macros.
1944	qqCXX_FOR_TARGET=`echo "$qCXX_FOR_TARGET" \| sed -e 's,[[$]][[$]],$$$$,g'`
1945	qqRAW_CXX_FOR_TARGET=`echo "$qRAW_CXX_FOR_TARGET" \| sed -e 's,[[$]][[$]],$$$$,g'`
1946
1947	# Wrap CC_FOR_TARGET and friends, for certain types of builds.
1948	CC_FOR_TARGET="\$(STAGE_CC_WRAPPER) ${CC_FOR_TARGET}"
1949	GCJ_FOR_TARGET="\$(STAGE_CC_WRAPPER) ${GCJ_FOR_TARGET}"
1950	CXX_FOR_TARGET="\$(STAGE_CC_WRAPPER) ${qCXX_FOR_TARGET}"
1951	RAW_CXX_FOR_TARGET="\$(STAGE_CC_WRAPPER) ${qRAW_CXX_FOR_TARGET}"
1952	CXX_FOR_TARGET_FOR_RECURSIVE_MAKE="\$(STAGE_CC_WRAPPER) ${qqCXX_FOR_TARGET}"
1953	RAW_CXX_FOR_TARGET_FOR_RECURSIVE_MAKE="\$(STAGE_CC_WRAPPER) ${qqRAW_CXX_FOR_TARGET}"
1954
1955	# Makefile fragments.
1956	host_makefile_frag=${srcdir}/${host_makefile_frag}
1957	target_makefile_frag=${srcdir}/${target_makefile_frag}
1958	alphaieee_frag=${srcdir}/${alphaieee_frag}
1959	ospace_frag=${srcdir}/${ospace_frag}
1960	AC_SUBST_FILE(host_makefile_frag)
1961	AC_SUBST_FILE(target_makefile_frag)
1962	AC_SUBST_FILE(alphaieee_frag)
1963	AC_SUBST_FILE(ospace_frag)
1964
1965	# Miscellanea: directories, flags, etc.
1966	AC_SUBST(SET_LIB_PATH)
1967	AC_SUBST(RPATH_ENVVAR)
1968	AC_SUBST(BUILD_PREFIX)
1969	AC_SUBST(BUILD_PREFIX_1)
1970	AC_SUBST(configlinks)
1971	AC_SUBST(gcc_version_trigger)
1972	AC_SUBST(gcc_version)
1973	AC_SUBST(tooldir)
1974	AC_SUBST(build_tooldir)
1975	AC_SUBST(GDB_TK)
1976	AC_SUBST(gxx_include_dir)
1977	AC_SUBST(libstdcxx_incdir)
1978
1979	# Build module lists & subconfigure args.
1980	AC_SUBST(build_subdir)
1981	AC_SUBST(build_configargs)
1982	AC_SUBST(configure_build_modules)
1983	AC_SUBST(all_build_modules)
1984
1985	# Host module lists & subconfigure args.
1986	AC_SUBST(host_configargs)
1987	AC_SUBST(configdirs)
1988	AC_SUBST(configure_host_modules)
1989	AC_SUBST(all_host_modules)
1990	AC_SUBST(check_host_modules)
1991	AC_SUBST(install_host_modules)
1992	AC_SUBST(install_host_modules_nogcc)
1993
1994	# Target module lists & subconfigure args.
1995	AC_SUBST(target_subdir)
1996	AC_SUBST(target_configargs)
1997	AC_SUBST(target_configdirs)
1998	AC_SUBST(configure_target_modules)
1999	AC_SUBST(all_target_modules)
2000	AC_SUBST(check_target_modules)
2001	AC_SUBST(install_target_modules)
2002
2003	# Build tools.
2004	AC_SUBST(BISON)
2005	AC_SUBST(CC_FOR_BUILD)
2006	AC_SUBST(LEX)
2007	AC_SUBST(MAKEINFO)
2008	AC_SUBST(YACC)
2009	AC_SUBST(config_shell)
2010
2011	# Host tools.
2012	NCN_STRICT_CHECK_TOOL(AR, ar)
2013	NCN_STRICT_CHECK_TOOL(AS, as)
2014	NCN_STRICT_CHECK_TOOL(DLLTOOL, dlltool)
2015	NCN_STRICT_CHECK_TOOL(LD, ld)
2016	NCN_STRICT_CHECK_TOOL(NM, nm)
2017	NCN_STRICT_CHECK_TOOL(RANLIB, ranlib, :)
2018	NCN_STRICT_CHECK_TOOL(WINDRES, windres)
2019	NCN_STRICT_CHECK_TOOL(OBJCOPY, objcopy)
2020	NCN_STRICT_CHECK_TOOL(OBJDUMP, objdump)
2021	AC_SUBST(CC)
2022	AC_SUBST(CXX)
2023	AC_SUBST(CFLAGS)
2024	AC_SUBST(CXXFLAGS)
2025	AC_SUBST(DEFAULT_YACC)
2026	AC_SUBST(DEFAULT_LEX)
2027	AC_SUBST(DEFAULT_M4)
2028
2029	# Target tools.
2030	NCN_STRICT_CHECK_TARGET_TOOL(AR_FOR_TARGET, ar)
2031	NCN_STRICT_CHECK_TARGET_TOOL(AS_FOR_TARGET, as)
2032	NCN_STRICT_CHECK_TARGET_TOOL(DLLTOOL_FOR_TARGET, dlltool)
2033	NCN_STRICT_CHECK_TARGET_TOOL(LD_FOR_TARGET, ld)
2034	NCN_STRICT_CHECK_TARGET_TOOL(NM_FOR_TARGET, nm)
2035	NCN_STRICT_CHECK_TARGET_TOOL(RANLIB_FOR_TARGET, ranlib, :)
2036	NCN_STRICT_CHECK_TARGET_TOOL(WINDRES_FOR_TARGET, windres)
2037
2038	AC_SUBST(GCC_FOR_TARGET)
2039	AC_SUBST(FLAGS_FOR_TARGET)
2040	AC_SUBST(CC_FOR_TARGET)
2041	AC_SUBST(GCJ_FOR_TARGET)
2042	AC_SUBST(CXX_FOR_TARGET)
2043	AC_SUBST(RAW_CXX_FOR_TARGET)
2044	AC_SUBST(CXX_FOR_TARGET_FOR_RECURSIVE_MAKE)
2045	AC_SUBST(RAW_CXX_FOR_TARGET_FOR_RECURSIVE_MAKE)
2046
2047	# Fix up target tools.
2048	if test "x${build}" = "x${host}" ; then
2049	# In this case, the newly built tools can and should be used,
2050	# so we override the results of the autoconf tests.
2051	# This should really only happen when the tools are actually being built,
2052	# but that's a further refinement. The new build scheme, where
2053	# tools are built into a structure paralleling where they're installed,
2054	# should also eliminate all of this cleanly.
2055	AR_FOR_TARGET="\$(USUAL_AR_FOR_TARGET)"
2056	AS_FOR_TARGET="\$(USUAL_AS_FOR_TARGET)"
2057	DLLTOOL_FOR_TARGET="\$(USUAL_DLLTOOL_FOR_TARGET)"
2058	LD_FOR_TARGET="\$(USUAL_LD_FOR_TARGET)"
2059	NM_FOR_TARGET="\$(USUAL_NM_FOR_TARGET)"
2060	RANLIB_FOR_TARGET="\$(USUAL_RANLIB_FOR_TARGET)"
2061	WINDRES_FOR_TARGET="\$(USUAL_WINDRES_FOR_TARGET)"
2062	fi
2063	# Certain tools may need extra flags.
2064	AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
2065	RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
2066	NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
2067
2068	AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
2069	AC_ARG_ENABLE(maintainer-mode,
2070	[ --enable-maintainer-mode enable make rules and dependencies not useful
2071	(and sometimes confusing) to the casual installer],
2072	USE_MAINTAINER_MODE=$enableval,
2073	USE_MAINTAINER_MODE=no)
2074	AC_MSG_RESULT($USE_MAINTAINER_MODE)
2075	AC_SUBST(MAINTAINER_MODE_TRUE)
2076	AC_SUBST(MAINTAINER_MODE_FALSE)
2077	if test "$USE_MAINTAINER_MODE" = yes; then
2078	MAINTAINER_MODE_TRUE=
2079	MAINTAINER_MODE_FALSE='#'
2080	else
2081	MAINTAINER_MODE_TRUE='#'
2082	MAINTAINER_MODE_FALSE=
2083	fi
2084	MAINT=$MAINTAINER_MODE_TRUE
2085	AC_SUBST(MAINT)dnl
2086
2087	AC_OUTPUT(Makefile)

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format