OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [configure] - Blame information for rev 868

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
#! /bin/sh
2
 
3
# Guess values for system-dependent variables and create Makefiles.
4
# Generated automatically using autoconf version 2.13
5
# Copyright (C) 1992, 93, 94, 95, 96 Free Software Foundation, Inc.
6
#
7
# This configure script is free software; the Free Software Foundation
8
# gives unlimited permission to copy, distribute and modify it.
9
 
10
# Defaults:
11
ac_help=
12
ac_default_prefix=/usr/local
13
# Any additions from configure.in:
14
ac_help="$ac_help
15
  --with-build-libsubdir=[DIR]  Directory where to find libraries for build system"
16
ac_help="$ac_help
17
  --enable-libada        Builds libada directory"
18
ac_help="$ac_help
19
  --enable-libssp        Builds libssp directory"
20
ac_help="$ac_help
21
  --with-mpfr-dir=PATH    This option has been REMOVED"
22
ac_help="$ac_help
23
  --with-mpfr=PATH        Specify prefix directory for installed MPFR package
24
                          Equivalent to --with-mpfr-include=PATH/include
25
                          plus --with-mpfr-lib=PATH/lib"
26
ac_help="$ac_help
27
  --with-mpfr-include=PATH
28
                          Specify directory for installed MPFR include files"
29
ac_help="$ac_help
30
  --with-mpfr-lib=PATH    Specify the directory for the installed MPFR library"
31
ac_help="$ac_help
32
  --with-gmp-dir=PATH     This option has been REMOVED"
33
ac_help="$ac_help
34
  --with-gmp=PATH         Specify prefix directory for the installed GMP package
35
                          Equivalent to --with-gmp-include=PATH/include
36
                          plus --with-gmp-lib=PATH/lib"
37
ac_help="$ac_help
38
  --with-gmp-include=PATH Specify directory for installed GMP include files"
39
ac_help="$ac_help
40
  --with-gmp-lib=PATH     Specify the directory for the installed GMP library"
41
ac_help="$ac_help
42
  --enable-objc-gc       enable the use of Boehm's garbage collector with
43
                          the GNU Objective-C runtime."
44
ac_help="$ac_help
45
  --with-build-sysroot=sysroot
46
                          use sysroot as the system root during the build"
47
ac_help="$ac_help
48
  --enable-bootstrap           Enable bootstrapping [yes if native build]"
49
ac_help="$ac_help
50
  --enable-serial-[{host,target,build}-]configure
51
                          Force sequential configuration of
52
                          sub-packages for the host, target or build
53
                          machine, or all sub-packages"
54
ac_help="$ac_help
55
  --with-build-time-tools=path
56
                          use given path to find target tools during the build"
57
ac_help="$ac_help
58
  --enable-maintainer-mode enable make rules and dependencies not useful
59
                          (and sometimes confusing) to the casual installer"
60
ac_help="$ac_help
61
  --enable-stage1-checking[=all]   choose additional checking for stage1
62
                          of the compiler."
63
ac_help="$ac_help
64
  --enable-werror         enable -Werror in bootstrap stage2 and later"
65
ac_help="$ac_help
66
  --with-datarootdir    Use datarootdir as the data root directory."
67
ac_help="$ac_help
68
  --with-docdir Install documentation in this directory."
69
ac_help="$ac_help
70
  --with-htmldir        Install html in this directory."
71
 
72
# Initialize some variables set by options.
73
# The variables have the same names as the options, with
74
# dashes changed to underlines.
75
build=NONE
76
cache_file=./config.cache
77
exec_prefix=NONE
78
host=NONE
79
no_create=
80
nonopt=NONE
81
no_recursion=
82
prefix=NONE
83
program_prefix=NONE
84
program_suffix=NONE
85
program_transform_name=s,x,x,
86
silent=
87
site=
88
srcdir=
89
target=NONE
90
verbose=
91
x_includes=NONE
92
x_libraries=NONE
93
bindir='${exec_prefix}/bin'
94
sbindir='${exec_prefix}/sbin'
95
libexecdir='${exec_prefix}/libexec'
96
datadir='${prefix}/share'
97
sysconfdir='${prefix}/etc'
98
sharedstatedir='${prefix}/com'
99
localstatedir='${prefix}/var'
100
libdir='${exec_prefix}/lib'
101
includedir='${prefix}/include'
102
oldincludedir='/usr/include'
103
infodir='${prefix}/info'
104
mandir='${prefix}/man'
105
 
106
# Initialize some other variables.
107
subdirs=
108
MFLAGS= MAKEFLAGS=
109
SHELL=${CONFIG_SHELL-/bin/sh}
110
# Maximum number of lines to put in a shell here document.
111
ac_max_here_lines=12
112
 
113
ac_prev=
114
for ac_option
115
do
116
 
117
  # If the previous option needs an argument, assign it.
118
  if test -n "$ac_prev"; then
119
    eval "$ac_prev=\$ac_option"
120
    ac_prev=
121
    continue
122
  fi
123
 
124
  case "$ac_option" in
125
  -*=*) ac_optarg=`echo "$ac_option" | sed 's/[-_a-zA-Z0-9]*=//'` ;;
126
  *) ac_optarg= ;;
127
  esac
128
 
129
  # Accept the important Cygnus configure options, so we can diagnose typos.
130
 
131
  case "$ac_option" in
132
 
133
  -bindir | --bindir | --bindi | --bind | --bin | --bi)
134
    ac_prev=bindir ;;
135
  -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
136
    bindir="$ac_optarg" ;;
137
 
138
  -build | --build | --buil | --bui | --bu)
139
    ac_prev=build ;;
140
  -build=* | --build=* | --buil=* | --bui=* | --bu=*)
141
    build="$ac_optarg" ;;
142
 
143
  -cache-file | --cache-file | --cache-fil | --cache-fi \
144
  | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
145
    ac_prev=cache_file ;;
146
  -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
147
  | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
148
    cache_file="$ac_optarg" ;;
149
 
150
  -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
151
    ac_prev=datadir ;;
152
  -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
153
  | --da=*)
154
    datadir="$ac_optarg" ;;
155
 
156
  -disable-* | --disable-*)
157
    ac_feature=`echo $ac_option|sed -e 's/-*disable-//'`
158
    # Reject names that are not valid shell variable names.
159
    if test -n "`echo $ac_feature| sed 's/[-a-zA-Z0-9_]//g'`"; then
160
      { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; }
161
    fi
162
    ac_feature=`echo $ac_feature| sed 's/-/_/g'`
163
    eval "enable_${ac_feature}=no" ;;
164
 
165
  -enable-* | --enable-*)
166
    ac_feature=`echo $ac_option|sed -e 's/-*enable-//' -e 's/=.*//'`
167
    # Reject names that are not valid shell variable names.
168
    if test -n "`echo $ac_feature| sed 's/[-_a-zA-Z0-9]//g'`"; then
169
      { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; }
170
    fi
171
    ac_feature=`echo $ac_feature| sed 's/-/_/g'`
172
    case "$ac_option" in
173
      *=*) ;;
174
      *) ac_optarg=yes ;;
175
    esac
176
    eval "enable_${ac_feature}='$ac_optarg'" ;;
177
 
178
  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
179
  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
180
  | --exec | --exe | --ex)
181
    ac_prev=exec_prefix ;;
182
  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
183
  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
184
  | --exec=* | --exe=* | --ex=*)
185
    exec_prefix="$ac_optarg" ;;
186
 
187
  -gas | --gas | --ga | --g)
188
    # Obsolete; use --with-gas.
189
    with_gas=yes ;;
190
 
191
  -help | --help | --hel | --he)
192
    # Omit some internal or obsolete options to make the list less imposing.
193
    # This message is too long to be a string in the A/UX 3.1 sh.
194
    cat << EOF
195
Usage: configure [options] [host]
196
Options: [defaults in brackets after descriptions]
197
Configuration:
198
  --cache-file=FILE       cache test results in FILE
199
  --help                  print this message
200
  --no-create             do not create output files
201
  --quiet, --silent       do not print \`checking...' messages
202
  --version               print the version of autoconf that created configure
203
Directory and file names:
204
  --prefix=PREFIX         install architecture-independent files in PREFIX
205
                          [$ac_default_prefix]
206
  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
207
                          [same as prefix]
208
  --bindir=DIR            user executables in DIR [EPREFIX/bin]
209
  --sbindir=DIR           system admin executables in DIR [EPREFIX/sbin]
210
  --libexecdir=DIR        program executables in DIR [EPREFIX/libexec]
211
  --datadir=DIR           read-only architecture-independent data in DIR
212
                          [PREFIX/share]
213
  --sysconfdir=DIR        read-only single-machine data in DIR [PREFIX/etc]
214
  --sharedstatedir=DIR    modifiable architecture-independent data in DIR
215
                          [PREFIX/com]
216
  --localstatedir=DIR     modifiable single-machine data in DIR [PREFIX/var]
217
  --libdir=DIR            object code libraries in DIR [EPREFIX/lib]
218
  --includedir=DIR        C header files in DIR [PREFIX/include]
219
  --oldincludedir=DIR     C header files for non-gcc in DIR [/usr/include]
220
  --infodir=DIR           info documentation in DIR [PREFIX/info]
221
  --mandir=DIR            man documentation in DIR [PREFIX/man]
222
  --srcdir=DIR            find the sources in DIR [configure dir or ..]
223
  --program-prefix=PREFIX prepend PREFIX to installed program names
224
  --program-suffix=SUFFIX append SUFFIX to installed program names
225
  --program-transform-name=PROGRAM
226
                          run sed PROGRAM on installed program names
227
EOF
228
    cat << EOF
229
Host type:
230
  --build=BUILD           configure for building on BUILD [BUILD=HOST]
231
  --host=HOST             configure for HOST [guessed]
232
  --target=TARGET         configure for TARGET [TARGET=HOST]
233
Features and packages:
234
  --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
235
  --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
236
  --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
237
  --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
238
  --x-includes=DIR        X include files are in DIR
239
  --x-libraries=DIR       X library files are in DIR
240
EOF
241
    if test -n "$ac_help"; then
242
      echo "--enable and --with options recognized:$ac_help"
243
    fi
244
    exit 0 ;;
245
 
246
  -host | --host | --hos | --ho)
247
    ac_prev=host ;;
248
  -host=* | --host=* | --hos=* | --ho=*)
249
    host="$ac_optarg" ;;
250
 
251
  -includedir | --includedir | --includedi | --included | --include \
252
  | --includ | --inclu | --incl | --inc)
253
    ac_prev=includedir ;;
254
  -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
255
  | --includ=* | --inclu=* | --incl=* | --inc=*)
256
    includedir="$ac_optarg" ;;
257
 
258
  -infodir | --infodir | --infodi | --infod | --info | --inf)
259
    ac_prev=infodir ;;
260
  -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
261
    infodir="$ac_optarg" ;;
262
 
263
  -libdir | --libdir | --libdi | --libd)
264
    ac_prev=libdir ;;
265
  -libdir=* | --libdir=* | --libdi=* | --libd=*)
266
    libdir="$ac_optarg" ;;
267
 
268
  -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
269
  | --libexe | --libex | --libe)
270
    ac_prev=libexecdir ;;
271
  -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
272
  | --libexe=* | --libex=* | --libe=*)
273
    libexecdir="$ac_optarg" ;;
274
 
275
  -localstatedir | --localstatedir | --localstatedi | --localstated \
276
  | --localstate | --localstat | --localsta | --localst \
277
  | --locals | --local | --loca | --loc | --lo)
278
    ac_prev=localstatedir ;;
279
  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
280
  | --localstate=* | --localstat=* | --localsta=* | --localst=* \
281
  | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
282
    localstatedir="$ac_optarg" ;;
283
 
284
  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
285
    ac_prev=mandir ;;
286
  -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
287
    mandir="$ac_optarg" ;;
288
 
289
  -nfp | --nfp | --nf)
290
    # Obsolete; use --without-fp.
291
    with_fp=no ;;
292
 
293
  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
294
  | --no-cr | --no-c)
295
    no_create=yes ;;
296
 
297
  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
298
  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
299
    no_recursion=yes ;;
300
 
301
  -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
302
  | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
303
  | --oldin | --oldi | --old | --ol | --o)
304
    ac_prev=oldincludedir ;;
305
  -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
306
  | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
307
  | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
308
    oldincludedir="$ac_optarg" ;;
309
 
310
  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
311
    ac_prev=prefix ;;
312
  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
313
    prefix="$ac_optarg" ;;
314
 
315
  -program-prefix | --program-prefix | --program-prefi | --program-pref \
316
  | --program-pre | --program-pr | --program-p)
317
    ac_prev=program_prefix ;;
318
  -program-prefix=* | --program-prefix=* | --program-prefi=* \
319
  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
320
    program_prefix="$ac_optarg" ;;
321
 
322
  -program-suffix | --program-suffix | --program-suffi | --program-suff \
323
  | --program-suf | --program-su | --program-s)
324
    ac_prev=program_suffix ;;
325
  -program-suffix=* | --program-suffix=* | --program-suffi=* \
326
  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
327
    program_suffix="$ac_optarg" ;;
328
 
329
  -program-transform-name | --program-transform-name \
330
  | --program-transform-nam | --program-transform-na \
331
  | --program-transform-n | --program-transform- \
332
  | --program-transform | --program-transfor \
333
  | --program-transfo | --program-transf \
334
  | --program-trans | --program-tran \
335
  | --progr-tra | --program-tr | --program-t)
336
    ac_prev=program_transform_name ;;
337
  -program-transform-name=* | --program-transform-name=* \
338
  | --program-transform-nam=* | --program-transform-na=* \
339
  | --program-transform-n=* | --program-transform-=* \
340
  | --program-transform=* | --program-transfor=* \
341
  | --program-transfo=* | --program-transf=* \
342
  | --program-trans=* | --program-tran=* \
343
  | --progr-tra=* | --program-tr=* | --program-t=*)
344
    program_transform_name="$ac_optarg" ;;
345
 
346
  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
347
  | -silent | --silent | --silen | --sile | --sil)
348
    silent=yes ;;
349
 
350
  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
351
    ac_prev=sbindir ;;
352
  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
353
  | --sbi=* | --sb=*)
354
    sbindir="$ac_optarg" ;;
355
 
356
  -sharedstatedir | --sharedstatedir | --sharedstatedi \
357
  | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
358
  | --sharedst | --shareds | --shared | --share | --shar \
359
  | --sha | --sh)
360
    ac_prev=sharedstatedir ;;
361
  -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
362
  | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
363
  | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
364
  | --sha=* | --sh=*)
365
    sharedstatedir="$ac_optarg" ;;
366
 
367
  -site | --site | --sit)
368
    ac_prev=site ;;
369
  -site=* | --site=* | --sit=*)
370
    site="$ac_optarg" ;;
371
 
372
  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
373
    ac_prev=srcdir ;;
374
  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
375
    srcdir="$ac_optarg" ;;
376
 
377
  -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
378
  | --syscon | --sysco | --sysc | --sys | --sy)
379
    ac_prev=sysconfdir ;;
380
  -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
381
  | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
382
    sysconfdir="$ac_optarg" ;;
383
 
384
  -target | --target | --targe | --targ | --tar | --ta | --t)
385
    ac_prev=target ;;
386
  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
387
    target="$ac_optarg" ;;
388
 
389
  -v | -verbose | --verbose | --verbos | --verbo | --verb)
390
    verbose=yes ;;
391
 
392
  -version | --version | --versio | --versi | --vers)
393
    echo "configure generated by autoconf version 2.13"
394
    exit 0 ;;
395
 
396
  -with-* | --with-*)
397
    ac_package=`echo $ac_option|sed -e 's/-*with-//' -e 's/=.*//'`
398
    # Reject names that are not valid shell variable names.
399
    if test -n "`echo $ac_package| sed 's/[-_a-zA-Z0-9]//g'`"; then
400
      { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; }
401
    fi
402
    ac_package=`echo $ac_package| sed 's/-/_/g'`
403
    case "$ac_option" in
404
      *=*) ;;
405
      *) ac_optarg=yes ;;
406
    esac
407
    eval "with_${ac_package}='$ac_optarg'" ;;
408
 
409
  -without-* | --without-*)
410
    ac_package=`echo $ac_option|sed -e 's/-*without-//'`
411
    # Reject names that are not valid shell variable names.
412
    if test -n "`echo $ac_package| sed 's/[-a-zA-Z0-9_]//g'`"; then
413
      { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; }
414
    fi
415
    ac_package=`echo $ac_package| sed 's/-/_/g'`
416
    eval "with_${ac_package}=no" ;;
417
 
418
  --x)
419
    # Obsolete; use --with-x.
420
    with_x=yes ;;
421
 
422
  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
423
  | --x-incl | --x-inc | --x-in | --x-i)
424
    ac_prev=x_includes ;;
425
  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
426
  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
427
    x_includes="$ac_optarg" ;;
428
 
429
  -x-libraries | --x-libraries | --x-librarie | --x-librari \
430
  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
431
    ac_prev=x_libraries ;;
432
  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
433
  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
434
    x_libraries="$ac_optarg" ;;
435
 
436
  -*) { echo "configure: error: $ac_option: invalid option; use --help to show usage" 1>&2; exit 1; }
437
    ;;
438
 
439
  *)
440
    if test -n "`echo $ac_option| sed 's/[-a-z0-9.]//g'`"; then
441
      echo "configure: warning: $ac_option: invalid host type" 1>&2
442
    fi
443
    if test "x$nonopt" != xNONE; then
444
      { echo "configure: error: can only configure for one host and one target at a time" 1>&2; exit 1; }
445
    fi
446
    nonopt="$ac_option"
447
    ;;
448
 
449
  esac
450
done
451
 
452
if test -n "$ac_prev"; then
453
  { echo "configure: error: missing argument to --`echo $ac_prev | sed 's/_/-/g'`" 1>&2; exit 1; }
454
fi
455
 
456
trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15
457
 
458
# File descriptor usage:
459
# 0 standard input
460
# 1 file creation
461
# 2 errors and warnings
462
# 3 some systems may open it to /dev/tty
463
# 4 used on the Kubota Titan
464
# 6 checking for... messages and results
465
# 5 compiler messages saved in config.log
466
if test "$silent" = yes; then
467
  exec 6>/dev/null
468
else
469
  exec 6>&1
470
fi
471
exec 5>./config.log
472
 
473
echo "\
474
This file contains any messages produced by compilers while
475
running configure, to aid debugging if configure makes a mistake.
476
" 1>&5
477
 
478
# Strip out --no-create and --no-recursion so they do not pile up.
479
# Also quote any args containing shell metacharacters.
480
ac_configure_args=
481
for ac_arg
482
do
483
  case "$ac_arg" in
484
  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
485
  | --no-cr | --no-c) ;;
486
  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
487
  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) ;;
488
  *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?]*)
489
  ac_configure_args="$ac_configure_args '$ac_arg'" ;;
490
  *) ac_configure_args="$ac_configure_args $ac_arg" ;;
491
  esac
492
done
493
 
494
# NLS nuisances.
495
# Only set these to C if already set.  These must not be set unconditionally
496
# because not all systems understand e.g. LANG=C (notably SCO).
497
# Fixing LC_MESSAGES prevents Solaris sh from translating var values in `set'!
498
# Non-C LC_CTYPE values break the ctype check.
499
if test "${LANG+set}"   = set; then LANG=C;   export LANG;   fi
500
if test "${LC_ALL+set}" = set; then LC_ALL=C; export LC_ALL; fi
501
if test "${LC_MESSAGES+set}" = set; then LC_MESSAGES=C; export LC_MESSAGES; fi
502
if test "${LC_CTYPE+set}"    = set; then LC_CTYPE=C;    export LC_CTYPE;    fi
503
 
504
# confdefs.h avoids OS command line length limits that DEFS can exceed.
505
rm -rf conftest* confdefs.h
506
# AIX cpp loses on an empty file, so make sure it contains at least a newline.
507
echo > confdefs.h
508
 
509
# A filename unique to this package, relative to the directory that
510
# configure is in, which we can look for to find out if srcdir is correct.
511
ac_unique_file=move-if-change
512
 
513
# Find the source files, if location was not specified.
514
if test -z "$srcdir"; then
515
  ac_srcdir_defaulted=yes
516
  # Try the directory containing this script, then its parent.
517
  ac_prog=$0
518
  ac_confdir=`echo $ac_prog|sed 's%/[^/][^/]*$%%'`
519
  test "x$ac_confdir" = "x$ac_prog" && ac_confdir=.
520
  srcdir=$ac_confdir
521
  if test ! -r $srcdir/$ac_unique_file; then
522
    srcdir=..
523
  fi
524
else
525
  ac_srcdir_defaulted=no
526
fi
527
if test ! -r $srcdir/$ac_unique_file; then
528
  if test "$ac_srcdir_defaulted" = yes; then
529
    { echo "configure: error: can not find sources in $ac_confdir or .." 1>&2; exit 1; }
530
  else
531
    { echo "configure: error: can not find sources in $srcdir" 1>&2; exit 1; }
532
  fi
533
fi
534
srcdir=`echo "${srcdir}" | sed 's%\([^/]\)/*$%\1%'`
535
 
536
# Prefer explicitly selected file to automatically selected ones.
537
if test -z "$CONFIG_SITE"; then
538
  if test "x$prefix" != xNONE; then
539
    CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
540
  else
541
    CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
542
  fi
543
fi
544
for ac_site_file in $CONFIG_SITE; do
545
  if test -r "$ac_site_file"; then
546
    echo "loading site script $ac_site_file"
547
    . "$ac_site_file"
548
  fi
549
done
550
 
551
if test -r "$cache_file"; then
552
  echo "loading cache $cache_file"
553
  . $cache_file
554
else
555
  echo "creating cache $cache_file"
556
  > $cache_file
557
fi
558
 
559
ac_ext=c
560
# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
561
ac_cpp='$CPP $CPPFLAGS'
562
ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
563
ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
564
cross_compiling=$ac_cv_prog_cc_cross
565
 
566
ac_exeext=
567
ac_objext=o
568
if (echo "testing\c"; echo 1,2,3) | grep c >/dev/null; then
569
  # Stardent Vistra SVR4 grep lacks -e, says ghazi@caip.rutgers.edu.
570
  if (echo -n testing; echo 1,2,3) | sed s/-n/xn/ | grep xn >/dev/null; then
571
    ac_n= ac_c='
572
' ac_t='        '
573
  else
574
    ac_n=-n ac_c= ac_t=
575
  fi
576
else
577
  ac_n= ac_c='\c' ac_t=
578
fi
579
 
580
 
581
 
582
ac_aux_dir=
583
for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
584
  if test -f $ac_dir/install-sh; then
585
    ac_aux_dir=$ac_dir
586
    ac_install_sh="$ac_aux_dir/install-sh -c"
587
    break
588
  elif test -f $ac_dir/install.sh; then
589
    ac_aux_dir=$ac_dir
590
    ac_install_sh="$ac_aux_dir/install.sh -c"
591
    break
592
  fi
593
done
594
if test -z "$ac_aux_dir"; then
595
  { echo "configure: error: can not find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." 1>&2; exit 1; }
596
fi
597
ac_config_guess=$ac_aux_dir/config.guess
598
ac_config_sub=$ac_aux_dir/config.sub
599
ac_configure=$ac_aux_dir/configure # This should be Cygnus configure.
600
 
601
 
602
# Do some error checking and defaulting for the host and target type.
603
# The inputs are:
604
#    configure --host=HOST --target=TARGET --build=BUILD NONOPT
605
#
606
# The rules are:
607
# 1. You are not allowed to specify --host, --target, and nonopt at the
608
#    same time.
609
# 2. Host defaults to nonopt.
610
# 3. If nonopt is not specified, then host defaults to the current host,
611
#    as determined by config.guess.
612
# 4. Target and build default to nonopt.
613
# 5. If nonopt is not specified, then target and build default to host.
614
 
615
# The aliases save the names the user supplied, while $host etc.
616
# will get canonicalized.
617
case $host---$target---$nonopt in
618
NONE---*---* | *---NONE---* | *---*---NONE) ;;
619
*) { echo "configure: error: can only configure for one host and one target at a time" 1>&2; exit 1; } ;;
620
esac
621
 
622
 
623
# Make sure we can run config.sub.
624
if ${CONFIG_SHELL-/bin/sh} $ac_config_sub sun4 >/dev/null 2>&1; then :
625
else { echo "configure: error: can not run $ac_config_sub" 1>&2; exit 1; }
626
fi
627
 
628
echo $ac_n "checking host system type""... $ac_c" 1>&6
629
echo "configure:630: checking host system type" >&5
630
 
631
host_alias=$host
632
case "$host_alias" in
633
NONE)
634
  case $nonopt in
635
  NONE)
636
    if host_alias=`${CONFIG_SHELL-/bin/sh} $ac_config_guess`; then :
637
    else { echo "configure: error: can not guess host type; you must specify one" 1>&2; exit 1; }
638
    fi ;;
639
  *) host_alias=$nonopt ;;
640
  esac ;;
641
esac
642
 
643
host=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $host_alias`
644
host_cpu=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
645
host_vendor=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
646
host_os=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
647
echo "$ac_t""$host" 1>&6
648
 
649
echo $ac_n "checking target system type""... $ac_c" 1>&6
650
echo "configure:651: checking target system type" >&5
651
 
652
target_alias=$target
653
case "$target_alias" in
654
NONE)
655
  case $nonopt in
656
  NONE) target_alias=$host_alias ;;
657
  *) target_alias=$nonopt ;;
658
  esac ;;
659
esac
660
 
661
target=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $target_alias`
662
target_cpu=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
663
target_vendor=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
664
target_os=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
665
echo "$ac_t""$target" 1>&6
666
 
667
echo $ac_n "checking build system type""... $ac_c" 1>&6
668
echo "configure:669: checking build system type" >&5
669
 
670
build_alias=$build
671
case "$build_alias" in
672
NONE)
673
  case $nonopt in
674
  NONE) build_alias=$host_alias ;;
675
  *) build_alias=$nonopt ;;
676
  esac ;;
677
esac
678
 
679
build=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $build_alias`
680
build_cpu=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
681
build_vendor=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
682
build_os=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
683
echo "$ac_t""$build" 1>&6
684
 
685
test "$host_alias" != "$target_alias" &&
686
  test "$program_prefix$program_suffix$program_transform_name" = \
687
    NONENONEs,x,x, &&
688
  program_prefix=${target_alias}-
689
 
690
if test "$program_transform_name" = s,x,x,; then
691
  program_transform_name=
692
else
693
  # Double any \ or $.  echo might interpret backslashes.
694
  cat <<\EOF_SED > conftestsed
695
s,\\,\\\\,g; s,\$,$$,g
696
EOF_SED
697
  program_transform_name="`echo $program_transform_name|sed -f conftestsed`"
698
  rm -f conftestsed
699
fi
700
test "$program_prefix" != NONE &&
701
  program_transform_name="s,^,${program_prefix},; $program_transform_name"
702
# Use a double $ so make ignores it.
703
test "$program_suffix" != NONE &&
704
  program_transform_name="s,\$\$,${program_suffix},; $program_transform_name"
705
 
706
# sed with no file args requires a program.
707
test "$program_transform_name" = "" && program_transform_name="s,x,x,"
708
 
709
 
710
# Get 'install' or 'install-sh' and its variants.
711
# Find a good install program.  We prefer a C program (faster),
712
# so one script is as good as another.  But avoid the broken or
713
# incompatible versions:
714
# SysV /etc/install, /usr/sbin/install
715
# SunOS /usr/etc/install
716
# IRIX /sbin/install
717
# AIX /bin/install
718
# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
719
# AFS /usr/afsws/bin/install, which mishandles nonexistent args
720
# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
721
# ./install, which can be erroneously created by make from ./install.sh.
722
echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6
723
echo "configure:724: checking for a BSD compatible install" >&5
724
if test -z "$INSTALL"; then
725
if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then
726
  echo $ac_n "(cached) $ac_c" 1>&6
727
else
728
    IFS="${IFS=         }"; ac_save_IFS="$IFS"; IFS=":"
729
  for ac_dir in $PATH; do
730
    # Account for people who put trailing slashes in PATH elements.
731
    case "$ac_dir/" in
732
    /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;;
733
    *)
734
      # OSF1 and SCO ODT 3.0 have their own names for install.
735
      # Don't use installbsd from OSF since it installs stuff as root
736
      # by default.
737
      for ac_prog in ginstall scoinst install; do
738
        if test -f $ac_dir/$ac_prog; then
739
          if test $ac_prog = install &&
740
            grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
741
            # AIX install.  It has an incompatible calling convention.
742
            :
743
          else
744
            ac_cv_path_install="$ac_dir/$ac_prog -c"
745
            break 2
746
          fi
747
        fi
748
      done
749
      ;;
750
    esac
751
  done
752
  IFS="$ac_save_IFS"
753
 
754
fi
755
  if test "${ac_cv_path_install+set}" = set; then
756
    INSTALL="$ac_cv_path_install"
757
  else
758
    # As a last resort, use the slow shell script.  We don't cache a
759
    # path for INSTALL within a source directory, because that will
760
    # break other packages using the cache if that directory is
761
    # removed, or if the path is relative.
762
    INSTALL="$ac_install_sh"
763
  fi
764
fi
765
echo "$ac_t""$INSTALL" 1>&6
766
 
767
# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
768
# It thinks the first close brace ends the variable substitution.
769
test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
770
 
771
test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}'
772
 
773
test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
774
 
775
echo $ac_n "checking whether ln works""... $ac_c" 1>&6
776
echo "configure:777: checking whether ln works" >&5
777
if eval "test \"`echo '$''{'acx_cv_prog_LN'+set}'`\" = set"; then
778
  echo $ac_n "(cached) $ac_c" 1>&6
779
else
780
  rm -f conftestdata_t
781
echo >conftestdata_f
782
if ln conftestdata_f conftestdata_t 2>/dev/null
783
then
784
  acx_cv_prog_LN=ln
785
else
786
  acx_cv_prog_LN=no
787
fi
788
rm -f conftestdata_f conftestdata_t
789
 
790
fi
791
if test $acx_cv_prog_LN = no; then
792
  LN="cp"
793
  echo "$ac_t""no, using $LN" 1>&6
794
else
795
  LN="$acx_cv_prog_LN"
796
  echo "$ac_t""yes" 1>&6
797
fi
798
 
799
echo $ac_n "checking whether ln -s works""... $ac_c" 1>&6
800
echo "configure:801: checking whether ln -s works" >&5
801
if eval "test \"`echo '$''{'ac_cv_prog_LN_S'+set}'`\" = set"; then
802
  echo $ac_n "(cached) $ac_c" 1>&6
803
else
804
  rm -f conftestdata
805
if ln -s X conftestdata 2>/dev/null
806
then
807
  rm -f conftestdata
808
  ac_cv_prog_LN_S="ln -s"
809
else
810
  ac_cv_prog_LN_S=ln
811
fi
812
fi
813
LN_S="$ac_cv_prog_LN_S"
814
if test "$ac_cv_prog_LN_S" = "ln -s"; then
815
  echo "$ac_t""yes" 1>&6
816
else
817
  echo "$ac_t""no" 1>&6
818
fi
819
 
820
 
821
### we might need to use some other shell than /bin/sh for running subshells
822
### If we are on Windows, search for the shell.  This will permit people
823
### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
824
### without also having to set CONFIG_SHELL.  This code will work when
825
### using bash, which sets OSTYPE.
826
case "${OSTYPE}" in
827
*win32*)
828
  if test x${CONFIG_SHELL} = x ; then
829
    if test ! -f /bin/sh ; then
830
      if test x${SHELL} != x && test -f ${SHELL} ; then
831
        CONFIG_SHELL=${SHELL}
832
        export CONFIG_SHELL
833
      else
834
        for prog in sh sh.exe bash bash.exe; do
835
          IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
836
          for dir in $PATH; do
837
            test -z "$dir" && dir=.
838
            if test -f $dir/$prog; then
839
              CONFIG_SHELL=$dir/$prog
840
              export CONFIG_SHELL
841
              break
842
            fi
843
          done
844
          IFS="$save_ifs"
845
          test -n "${CONFIG_SHELL}" && break
846
        done
847
      fi
848
    fi
849
  fi
850
  ;;
851
esac
852
 
853
config_shell=${CONFIG_SHELL-/bin/sh}
854
 
855
progname=$0
856
# if PWD already has a value, it is probably wrong.
857
if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
858
 
859
# Export original configure arguments for use by sub-configures.  These
860
# will be expanded by make, so quote '$'.
861
tmp="$progname $@"
862
sed -e 's,\$,$$,g' < conftestsed.out
863
$tmp
864
EOF_SED
865
TOPLEVEL_CONFIGURE_ARGUMENTS=`cat conftestsed.out`
866
rm -f conftestsed.out
867
 
868
 
869
moveifchange=${srcdir}/move-if-change
870
 
871
srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
872
 
873
# We pass INSTALL explicitly to sub-makes.  Make sure that it is not
874
# a relative path.
875
if test "$INSTALL" = "${srcdir}/install-sh -c"; then
876
  INSTALL="${srcpwd}/install-sh -c"
877
fi
878
 
879
# Set srcdir to "." if that's what it is.
880
# This is important for multilib support.
881
pwd=`${PWDCMD-pwd}`
882
if test "${pwd}" = "${srcpwd}" ; then
883
  srcdir=.
884
fi
885
 
886
topsrcdir=$srcpwd
887
 
888
extra_host_args=
889
 
890
### To add a new directory to the tree, first choose whether it is a target
891
### or a host dependent tool.  Then put it into the appropriate list
892
### (library or tools, host or target), doing a dependency sort.
893
 
894
# Subdirs will be configured in the order listed in build_configdirs,
895
# configdirs, or target_configdirs; see the serialization section below.
896
 
897
# Dependency sorting is only needed when *configuration* must be done in
898
# a particular order.  In all cases a dependency should be specified in
899
# the Makefile, whether or not it's implicitly specified here.
900
 
901
# Double entries in build_configdirs, configdirs, or target_configdirs may
902
# cause circular dependencies and break everything horribly.
903
 
904
# these library is used by various programs built for the build
905
# environment
906
#
907
build_libs="build-libiberty"
908
 
909
# these tools are built for the build environment
910
build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
911
 
912
# these libraries are used by various programs built for the host environment
913
#
914
host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber"
915
 
916
# these tools are built for the host environment
917
# Note, the powerpc-eabi build depends on sim occurring before gdb in order to
918
# know that we are building the simulator.
919
# binutils, gas and ld appear in that order because it makes sense to run
920
# "make check" in that particular order.
921
host_tools="texinfo byacc flex bison binutils gas ld fixincludes 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 gnattools"
922
 
923
# libgcj represents the runtime libraries only used by gcj.
924
libgcj="target-libffi \
925
        target-zlib \
926
        target-qthreads \
927
        target-libjava"
928
 
929
# these libraries are built for the target environment, and are built after
930
# the host libraries and the host tools (which may be a cross compiler)
931
#
932
target_libraries="target-libiberty \
933
                target-libgloss \
934
                target-newlib \
935
                target-libstdc++-v3 \
936
                target-libmudflap \
937
                target-libssp \
938
                target-libgfortran \
939
                target-boehm-gc \
940
                ${libgcj} \
941
                target-libobjc \
942
                target-libada \
943
                target-libgomp"
944
 
945
# these tools are built using the target libraries, and are intended to
946
# run only in the target environment
947
#
948
# note: any program that *uses* libraries that are in the "target_libraries"
949
# list belongs in this list.  those programs are also very likely
950
# candidates for the "native_only" list which follows
951
#
952
target_tools="target-examples target-groff target-gperf target-rda"
953
 
954
################################################################################
955
 
956
## All tools belong in one of the four categories, and are assigned above
957
## We assign ${configdirs} this way to remove all embedded newlines.  This
958
## is important because configure will choke if they ever get through.
959
## ${configdirs} is directories we build using the host tools.
960
## ${target_configdirs} is directories we build using the target tools.
961
configdirs=`echo ${host_libs} ${host_tools}`
962
target_configdirs=`echo ${target_libraries} ${target_tools}`
963
build_configdirs=`echo ${build_libs} ${build_tools}`
964
 
965
################################################################################
966
 
967
srcname="gnu development package"
968
 
969
# This gets set non-empty for some net releases of packages.
970
appdirs=""
971
 
972
# Define is_cross_compiler to save on calls to 'test'.
973
is_cross_compiler=
974
if test x"${host}" = x"${target}" ; then
975
  is_cross_compiler=no
976
else
977
  is_cross_compiler=yes
978
fi
979
 
980
# Find the build and target subdir names.
981
 case ${build_alias} in
982
  "") build_noncanonical=${build} ;;
983
  *) build_noncanonical=${build_alias} ;;
984
esac
985
 
986
 case ${host_alias} in
987
  "") host_noncanonical=${build_noncanonical} ;;
988
  *) host_noncanonical=${host_alias} ;;
989
esac
990
 
991
 case ${target_alias} in
992
  "") target_noncanonical=${host_noncanonical} ;;
993
  *) target_noncanonical=${target_alias} ;;
994
esac
995
 
996
 
997
# post-stage1 host modules use a different CC_FOR_BUILD so, in order to
998
# have matching libraries, they should use host libraries: Makefile.tpl
999
# arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1000
# However, they still use the build modules, because the corresponding
1001
# host modules (e.g. bison) are only built for the host when bootstrap
1002
# finishes. So:
1003
# - build_subdir is where we find build modules, and never changes.
1004
# - build_libsubdir is where we find build libraries, and can be overridden.
1005
 
1006
# Prefix 'build-' so this never conflicts with target_subdir.
1007
build_subdir="build-${build_noncanonical}"
1008
# Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1009
if test "${with_build_libsubdir+set}" = set; then
1010
  withval="$with_build_libsubdir"
1011
  build_libsubdir="$withval"
1012
else
1013
  build_libsubdir="$build_subdir"
1014
fi
1015
 
1016
# --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1017
if ( test $srcdir = . && test -d gcc ) \
1018
   || test -d $srcdir/../host-${host_noncanonical}; then
1019
  host_subdir="host-${host_noncanonical}"
1020
else
1021
  host_subdir=.
1022
fi
1023
# No prefix.
1024
target_subdir=${target_noncanonical}
1025
 
1026
 
1027
# Skipdirs are removed silently.
1028
skipdirs=
1029
# Noconfigdirs are removed loudly.
1030
noconfigdirs=""
1031
 
1032
use_gnu_ld=
1033
# Make sure we don't let GNU ld be added if we didn't want it.
1034
if test x$with_gnu_ld = xno ; then
1035
  use_gnu_ld=no
1036
  noconfigdirs="$noconfigdirs ld"
1037
fi
1038
 
1039
use_gnu_as=
1040
# Make sure we don't let GNU as be added if we didn't want it.
1041
if test x$with_gnu_as = xno ; then
1042
  use_gnu_as=no
1043
  noconfigdirs="$noconfigdirs gas"
1044
fi
1045
 
1046
# some tools are so dependent upon X11 that if we're not building with X,
1047
# it's not even worth trying to configure, much less build, that tool.
1048
 
1049
case ${with_x} in
1050
  yes | "") ;; # the default value for this tree is that X11 is available
1051
  no)
1052
    skipdirs="${skipdirs} tk itcl libgui"
1053
    # We won't be able to build gdbtk without X.
1054
    enable_gdbtk=no
1055
    ;;
1056
  *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
1057
esac
1058
 
1059
# Some tools are only suitable for building in a "native" situation.
1060
# Remove these if host!=target.
1061
native_only="autoconf automake libtool fileutils find gawk gettext gzip hello indent m4 rcs recode sed shellutils tar textutils uudecode wdiff target-groff guile perl time ash bash bzip2 prms gnuserv target-gperf"
1062
 
1063
# Similarly, some are only suitable for cross toolchains.
1064
# Remove these if host=target.
1065
cross_only="target-libgloss target-newlib target-opcodes"
1066
 
1067
case $is_cross_compiler in
1068
  no) skipdirs="${skipdirs} ${cross_only}" ;;
1069
  yes) skipdirs="${skipdirs} ${native_only}" ;;
1070
esac
1071
 
1072
# If both --with-headers and --with-libs are specified, default to
1073
# --without-newlib.
1074
if test x"${with_headers}" != x && test x"${with_headers}" != xno \
1075
   && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
1076
  if test x"${with_newlib}" = x ; then
1077
    with_newlib=no
1078
  fi
1079
fi
1080
 
1081
# Recognize --with-newlib/--without-newlib.
1082
case ${with_newlib} in
1083
  no) skipdirs="${skipdirs} target-newlib" ;;
1084
  yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
1085
esac
1086
 
1087
# Configure extra directories which are host specific
1088
 
1089
case "${host}" in
1090
  *-cygwin*)
1091
    configdirs="$configdirs libtermcap" ;;
1092
esac
1093
 
1094
# A target can indicate whether a language isn't supported for some reason.
1095
# Only spaces may be used in this macro; not newlines or tabs.
1096
unsupported_languages=
1097
 
1098
# Remove more programs from consideration, based on the host or
1099
# target this usually means that a port of the program doesn't
1100
# exist yet.
1101
 
1102
case "${host}" in
1103
  hppa*64*-*-*)
1104
    noconfigdirs="$noconfigdirs byacc"
1105
    ;;
1106
  i[3456789]86-*-vsta)
1107
    noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
1108
    ;;
1109
  i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
1110
    noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
1111
    ;;
1112
  i[3456789]86-*-mingw32*)
1113
    # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
1114
    noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
1115
    ;;
1116
  i[3456789]86-*-beos*)
1117
    noconfigdirs="$noconfigdirs tk itcl libgui gdb"
1118
    ;;
1119
  *-*-cygwin*)
1120
    noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
1121
    ;;
1122
  *-*-netbsd*)
1123
    noconfigdirs="$noconfigdirs rcs"
1124
    ;;
1125
  ppc*-*-pe)
1126
    noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
1127
    ;;
1128
  powerpc-*-beos*)
1129
    noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
1130
    ;;
1131
esac
1132
 
1133
 
1134
# Check whether --enable-libada or --disable-libada was given.
1135
if test "${enable_libada+set}" = set; then
1136
  enableval="$enable_libada"
1137
  ENABLE_LIBADA=$enableval
1138
else
1139
  ENABLE_LIBADA=yes
1140
fi
1141
 
1142
if test "${ENABLE_LIBADA}" != "yes" ; then
1143
  noconfigdirs="$noconfigdirs gnattools"
1144
fi
1145
 
1146
# Check whether --enable-libssp or --disable-libssp was given.
1147
if test "${enable_libssp+set}" = set; then
1148
  enableval="$enable_libssp"
1149
  ENABLE_LIBSSP=$enableval
1150
else
1151
  ENABLE_LIBSSP=yes
1152
fi
1153
 
1154
 
1155
# Save it here so that, even in case of --enable-libgcj, if the Java
1156
# front-end isn't enabled, we still get libgcj disabled.
1157
libgcj_saved=$libgcj
1158
case $enable_libgcj in
1159
yes)
1160
  # If we reset it here, it won't get added to noconfigdirs in the
1161
  # target-specific build rules, so it will be forcibly enabled
1162
  # (unless the Java language itself isn't enabled).
1163
  libgcj=
1164
  ;;
1165
no)
1166
  # Make sure we get it printed in the list of not supported target libs.
1167
  noconfigdirs="$noconfigdirs ${libgcj}"
1168
  ;;
1169
esac
1170
 
1171
 
1172
# Disable libmudflap on some systems.
1173
if test x$enable_libmudflap = x ; then
1174
    case "${target}" in
1175
    *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
1176
        # Enable libmudflap by default in GNU and friends.
1177
        ;;
1178
    *-*-freebsd*)
1179
        # Enable libmudflap by default in FreeBSD.
1180
        ;;
1181
    *)
1182
        # Disable it by default everywhere else.
1183
        noconfigdirs="$noconfigdirs target-libmudflap"
1184
        ;;
1185
    esac
1186
fi
1187
 
1188
# Disable libgomp on non POSIX hosted systems.
1189
if test x$enable_libgomp = x ; then
1190
    # Enable libgomp by default on hosted POSIX systems.
1191
    case "${target}" in
1192
    *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
1193
        ;;
1194
    *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
1195
        ;;
1196
    *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
1197
        ;;
1198
    *-*-darwin* | *-*-aix*)
1199
        ;;
1200
    *)
1201
        noconfigdirs="$noconfigdirs target-libgomp"
1202
        ;;
1203
    esac
1204
fi
1205
 
1206
 
1207
case "${target}" in
1208
  *-*-chorusos)
1209
    noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
1210
    ;;
1211
  powerpc-*-darwin* | i[3456789]86-*-darwin*)
1212
    noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes gdb gprof"
1213
    noconfigdirs="$noconfigdirs sim target-rda"
1214
    ;;
1215
  *-*-darwin*)
1216
    noconfigdirs="$noconfigdirs ld gas gdb gprof"
1217
    noconfigdirs="$noconfigdirs sim target-rda"
1218
    noconfigdirs="$noconfigdirs ${libgcj}"
1219
    ;;
1220
  *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
1221
    noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
1222
    ;;
1223
  *-*-freebsd*)
1224
    noconfigdirs="$noconfigdirs target-newlib target-libgloss"
1225
    if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
1226
        && test -f /usr/local/include/gmp.h; then
1227
      with_gmp=/usr/local
1228
    fi
1229
 
1230
    # Skip some stuff that's unsupported on some FreeBSD configurations.
1231
    case "${target}" in
1232
      i*86-*-*) ;;
1233
      alpha*-*-*) ;;
1234
      *)
1235
        noconfigdirs="$noconfigdirs ${libgcj}"
1236
        ;;
1237
    esac
1238
    ;;
1239
  *-*-kaos*)
1240
    # Remove unsupported stuff on all kaOS configurations.
1241
    skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
1242
    skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
1243
    skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
1244
    noconfigdirs="$noconfigdirs target-libgloss"
1245
    ;;
1246
  *-*-netbsd*)
1247
    # Skip some stuff on all NetBSD configurations.
1248
    noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
1249
 
1250
    # Skip some stuff that's unsupported on some NetBSD configurations.
1251
    case "${target}" in
1252
      i*86-*-netbsdelf*) ;;
1253
      arm*-*-netbsdelf*) ;;
1254
      *)
1255
        noconfigdirs="$noconfigdirs ${libgcj}"
1256
        ;;
1257
    esac
1258
    ;;
1259
  *-*-netware*)
1260
    noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
1261
    ;;
1262
  *-*-rtems*)
1263
    noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
1264
    ;;
1265
    # The tpf target doesn't support gdb yet.
1266
  *-*-tpf*)
1267
    noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
1268
    ;;
1269
  *-*-uclinux*)
1270
    noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
1271
    ;;
1272
  *-*-vxworks*)
1273
    noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
1274
    ;;
1275
  alpha*-dec-osf*)
1276
    # ld works, but does not support shared libraries.
1277
    # newlib is not 64 bit ready.  I'm not sure about fileutils.
1278
    # gas doesn't generate exception information.
1279
    noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
1280
    ;;
1281
  alpha*-*-*vms*)
1282
    noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
1283
    ;;
1284
  alpha*-*-linux*)
1285
    # newlib is not 64 bit ready
1286
    noconfigdirs="$noconfigdirs target-newlib target-libgloss"
1287
    ;;
1288
  alpha*-*-*)
1289
    # newlib is not 64 bit ready
1290
    noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
1291
    ;;
1292
  am33_2.0-*-linux*)
1293
    noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
1294
    ;;
1295
  or32*-*-*)
1296
    noconfigdirs="$noconfigdirs target-libmudflap target-libiberty"
1297
    noconfigdirs="$noconfigdirs target-libgomp"
1298
    ;;
1299
  sh-*-linux*)
1300
    noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
1301
    ;;
1302
  sh*-*-pe|mips*-*-pe|*arm-wince-pe)
1303
    noconfigdirs="$noconfigdirs ${libgcj}"
1304
    noconfigdirs="$noconfigdirs target-examples"
1305
    noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
1306
    noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
1307
    noconfigdirs="$noconfigdirs expect dejagnu"
1308
    # the C++ libraries don't build on top of CE's C libraries
1309
    noconfigdirs="$noconfigdirs target-libstdc++-v3"
1310
    noconfigdirs="$noconfigdirs target-newlib"
1311
    case "${host}" in
1312
      *-*-cygwin*) ;; # keep gdb and readline
1313
      *) noconfigdirs="$noconfigdirs gdb readline"
1314
         ;;
1315
    esac
1316
    ;;
1317
  arc-*-*)
1318
    noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
1319
    ;;
1320
  arm-semi-aof )
1321
    ;;
1322
  arm-*-coff | strongarm-*-coff | xscale-*-coff)
1323
    noconfigdirs="$noconfigdirs ${libgcj}"
1324
    ;;
1325
  arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
1326
    noconfigdirs="$noconfigdirs target-libffi target-qthreads"
1327
    ;;
1328
  arm*-*-linux-gnueabi)
1329
    noconfigdirs="$noconfigdirs target-libffi target-qthreads"
1330
    noconfigdirs="$noconfigdirs target-libjava target-libobjc"
1331
    ;;
1332
  arm*-*-symbianelf*)
1333
    noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
1334
    ;;
1335
  arm-*-pe*)
1336
    noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
1337
    ;;
1338
  thumb-*-coff)
1339
    noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
1340
    ;;
1341
  thumb-*-elf)
1342
    noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
1343
    ;;
1344
  thumb-*-pe)
1345
    noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
1346
    ;;
1347
  arm-*-riscix*)
1348
    noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
1349
    ;;
1350
  avr-*-*)
1351
    noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
1352
    ;;
1353
  bfin-*-*)
1354
    noconfigdirs="$noconfigdirs gdb"
1355
    if test x${is_cross_compiler} != xno ; then
1356
      target_configdirs="${target_configdirs} target-bsp target-cygmon"
1357
    fi
1358
    ;;
1359
  c4x-*-* | tic4x-*-*)
1360
    noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
1361
    ;;
1362
  c54x*-*-* | tic54x-*-*)
1363
    noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
1364
    ;;
1365
  cris-*-* | crisv32-*-*)
1366
    unsupported_languages="$unsupported_languages java"
1367
    case "${target}" in
1368
      *-*-aout)
1369
        unsupported_languages="$unsupported_languages fortran"
1370
        noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
1371
      *-*-elf)
1372
        unsupported_languages="$unsupported_languages fortran"
1373
        noconfigdirs="$noconfigdirs target-boehm-gc";;
1374
      *-*-linux*)
1375
        noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
1376
      *)
1377
        unsupported_languages="$unsupported_languages fortran"
1378
        noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
1379
    esac
1380
    ;;
1381
  crx-*-*)
1382
    noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
1383
    ;;
1384
  d10v-*-*)
1385
    noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
1386
    ;;
1387
  d30v-*-*)
1388
    noconfigdirs="$noconfigdirs ${libgcj} gdb"
1389
    ;;
1390
  fr30-*-elf*)
1391
    noconfigdirs="$noconfigdirs ${libgcj} gdb"
1392
    ;;
1393
  frv-*-*)
1394
    noconfigdirs="$noconfigdirs ${libgcj}"
1395
    ;;
1396
  h8300*-*-*)
1397
    noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
1398
    ;;
1399
  h8500-*-*)
1400
    noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
1401
    ;;
1402
  hppa1.1-*-osf* | hppa1.1-*-bsd* )
1403
    ;;
1404
  hppa*64*-*-linux* | parisc*64*-*-linux*)
1405
    # In this case, it's because the hppa64-linux target is for
1406
    # the kernel only at this point and has no libc, and thus no
1407
    # headers, crt*.o, etc., all of which are needed by these.
1408
    noconfigdirs="$noconfigdirs target-zlib"
1409
    ;;
1410
  parisc*-*-linux* | hppa*-*-linux*)
1411
    ;;
1412
  hppa*-*-*elf* | \
1413
  hppa*-*-lites* | \
1414
  hppa*-*-openbsd* | \
1415
  hppa*64*-*-*)
1416
    noconfigdirs="$noconfigdirs ${libgcj}"
1417
    ;;
1418
  hppa*-hp-hpux11*)
1419
    noconfigdirs="$noconfigdirs ld shellutils"
1420
    ;;
1421
  hppa*-*-*)
1422
    # According to Alexandre Oliva , libjava won't
1423
    # build on HP-UX 10.20.
1424
    noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
1425
    ;;
1426
  i960-*-*)
1427
    noconfigdirs="$noconfigdirs ${libgcj} gdb"
1428
    ;;
1429
  ia64*-*-elf*)
1430
    # No gdb support yet.
1431
    noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
1432
    ;;
1433
  ia64*-**-hpux*)
1434
    # No gdb or ld support yet.
1435
    noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
1436
    ;;
1437
  i370-*-opened*)
1438
    ;;
1439
  i[3456789]86-*-coff | i[3456789]86-*-elf)
1440
    noconfigdirs="$noconfigdirs ${libgcj}"
1441
    ;;
1442
  i[3456789]86-*-linux*)
1443
    # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
1444
    # not build java stuff by default.
1445
    case "${target}" in
1446
      *-*-*libc1*)
1447
        noconfigdirs="$noconfigdirs ${libgcj}";;
1448
    esac
1449
 
1450
    # This section makes it possible to build newlib natively on linux.
1451
    # If we are using a cross compiler then don't configure newlib.
1452
    if test x${is_cross_compiler} != xno ; then
1453
      noconfigdirs="$noconfigdirs target-newlib"
1454
    fi
1455
    noconfigdirs="$noconfigdirs target-libgloss"
1456
    # If we are not using a cross compiler, do configure newlib.
1457
    # Note however, that newlib will only be configured in this situation
1458
    # if the --with-newlib option has been given, because otherwise
1459
    # 'target-newlib' will appear in skipdirs.
1460
    ;;
1461
  i[3456789]86-*-mingw32*)
1462
    target_configdirs="$target_configdirs target-winsup"
1463
    noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
1464
    ;;
1465
  *-*-cygwin*)
1466
    target_configdirs="$target_configdirs target-libtermcap target-winsup"
1467
    noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
1468
    # always build newlib if winsup directory is present.
1469
    if test -d "$srcdir/winsup/cygwin"; then
1470
      skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
1471
    elif test -d "$srcdir/newlib"; then
1472
      echo "Warning: winsup/cygwin is missing so newlib can't be built."
1473
    fi
1474
    ;;
1475
  i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
1476
  i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
1477
    ;;
1478
  i[3456789]86-*-pe)
1479
    noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
1480
    ;;
1481
  i[3456789]86-*-sco3.2v5*)
1482
    # The linker does not yet know about weak symbols in COFF,
1483
    # and is not configured to handle mixed ELF and COFF.
1484
    noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
1485
    ;;
1486
  i[3456789]86-*-sco*)
1487
    noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
1488
    ;;
1489
  i[3456789]86-*-solaris2*)
1490
    noconfigdirs="$noconfigdirs target-libgloss"
1491
    ;;
1492
  i[3456789]86-*-sysv4*)
1493
    noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
1494
    ;;
1495
  i[3456789]86-*-beos*)
1496
    noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
1497
    ;;
1498
  i[3456789]86-*-rdos*)
1499
    noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
1500
    ;;
1501
  m32r-*-*)
1502
    noconfigdirs="$noconfigdirs ${libgcj}"
1503
    ;;
1504
  m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
1505
    noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
1506
    ;;
1507
  m68k-*-elf*)
1508
    noconfigdirs="$noconfigdirs ${libgcj}"
1509
    ;;
1510
  m68k-*-coff*)
1511
    noconfigdirs="$noconfigdirs ${libgcj}"
1512
    ;;
1513
  mcore-*-pe*)
1514
  # The EPOC C++ environment does not support exceptions or rtti,
1515
  # and so building libstdc++-v3 tends not to always work.
1516
    noconfigdirs="$noconfigdirs target-libstdc++-v3"
1517
    ;;
1518
  mmix-*-*)
1519
    noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
1520
    unsupported_languages="$unsupported_languages fortran java"
1521
    ;;
1522
  mn10200-*-*)
1523
    noconfigdirs="$noconfigdirs ${libgcj}"
1524
    ;;
1525
  mn10300-*-*)
1526
    noconfigdirs="$noconfigdirs ${libgcj}"
1527
    ;;
1528
  mt-*-*)
1529
    noconfigdirs="$noconfigdirs sim"
1530
    ;;
1531
  powerpc-*-aix*)
1532
    # copied from rs6000-*-* entry
1533
    noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
1534
    ;;
1535
  powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
1536
    target_configdirs="$target_configdirs target-winsup"
1537
    noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
1538
    # always build newlib.
1539
    skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
1540
    ;;
1541
    # This is temporary until we can link against shared libraries
1542
  powerpcle-*-solaris*)
1543
    noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
1544
    ;;
1545
  powerpc-*-beos*)
1546
    noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
1547
    ;;
1548
  powerpc-*-eabi)
1549
    noconfigdirs="$noconfigdirs ${libgcj}"
1550
    ;;
1551
  powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
1552
    ;;
1553
  rs6000-*-lynxos*)
1554
    noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
1555
    ;;
1556
  rs6000-*-aix*)
1557
    noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
1558
    ;;
1559
  rs6000-*-*)
1560
    noconfigdirs="$noconfigdirs gprof ${libgcj}"
1561
    ;;
1562
  m68k-apollo-*)
1563
    noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
1564
    ;;
1565
  mips*-*-irix5*)
1566
    noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
1567
    ;;
1568
  mips*-*-irix6*)
1569
    # Linking libjava exceeds command-line length limits on at least
1570
    # IRIX 6.2, but not on IRIX 6.5.
1571
    # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
1572
    # 
1573
    noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
1574
    ;;
1575
  mips*-*-bsd*)
1576
    noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
1577
    ;;
1578
  mips64*-*-linux*)
1579
    noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
1580
    ;;
1581
  mips*-*-linux*)
1582
    noconfigdirs="$noconfigdirs target-newlib target-libgloss"
1583
    ;;
1584
  mips*-*-*)
1585
    noconfigdirs="$noconfigdirs gprof ${libgcj}"
1586
    ;;
1587
  romp-*-*)
1588
    noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
1589
    ;;
1590
  sh-*-* | sh64-*-*)
1591
    case "${host}" in
1592
      i[3456789]86-*-vsta) ;; # don't add gprof back in
1593
      i[3456789]86-*-go32*) ;; # don't add gprof back in
1594
      i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
1595
      *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
1596
    esac
1597
    noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
1598
    ;;
1599
  sparc-*-elf*)
1600
    noconfigdirs="$noconfigdirs ${libgcj}"
1601
    ;;
1602
  sparc64-*-elf*)
1603
    noconfigdirs="$noconfigdirs ${libgcj}"
1604
    ;;
1605
  sparclite-*-*)
1606
    noconfigdirs="$noconfigdirs ${libgcj}"
1607
    ;;
1608
  sparc-*-sunos4*)
1609
    noconfigdirs="$noconfigdirs ${libgcj}"
1610
    if test x${is_cross_compiler} != xno ; then
1611
           noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
1612
    else
1613
           use_gnu_ld=no
1614
    fi
1615
    ;;
1616
  sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
1617
    noconfigdirs="$noconfigdirs ${libgcj}"
1618
    ;;
1619
  sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
1620
    ;;
1621
  v810-*-*)
1622
    noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
1623
    ;;
1624
  v850-*-*)
1625
    noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
1626
    ;;
1627
  v850e-*-*)
1628
    noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
1629
    ;;
1630
  v850ea-*-*)
1631
    noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
1632
    ;;
1633
  vax-*-vms)
1634
    noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
1635
    ;;
1636
  vax-*-*)
1637
    noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
1638
    ;;
1639
  xtensa-*-*)
1640
    noconfigdirs="$noconfigdirs ${libgcj}"
1641
    ;;
1642
  ip2k-*-*)
1643
    noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
1644
    ;;
1645
  *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
1646
    noconfigdirs="$noconfigdirs target-newlib target-libgloss"
1647
    ;;
1648
  *-*-lynxos*)
1649
    noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
1650
    ;;
1651
  *-*-*)
1652
    noconfigdirs="$noconfigdirs ${libgcj}"
1653
    ;;
1654
esac
1655
 
1656
# If we aren't building newlib, then don't build libgloss, since libgloss
1657
# depends upon some newlib header files.
1658
case "${noconfigdirs}" in
1659
  *target-libgloss*) ;;
1660
  *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
1661
esac
1662
 
1663
# Work in distributions that contain no compiler tools, like Autoconf.
1664
tentative_cc=""
1665
host_makefile_frag=/dev/null
1666
if test -d ${srcdir}/config ; then
1667
case "${host}" in
1668
  m68k-hp-hpux*)
1669
    # Avoid "too much defining" errors from HPUX compiler.
1670
    tentative_cc="cc -Wp,-H256000"
1671
    # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
1672
    # If it's HP/UX ar, this should be harmless.
1673
    RANLIB="ar ts"
1674
    ;;
1675
  m68k-apollo-sysv*)
1676
    tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
1677
    ;;
1678
  m68k-apollo-bsd*)
1679
    #None of the Apollo compilers can compile gas or binutils.  The preprocessor
1680
    # chokes on bfd, the compiler won't let you assign integers to enums, and
1681
    # other problems.  Defining CC to gcc is a questionable way to say "don't use
1682
    # the apollo compiler" (the preferred version of GCC could be called cc,
1683
    # or whatever), but I'm not sure leaving CC as cc is any better...
1684
    #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
1685
    # Used to have BISON=yacc.
1686
    tentative_cc=gcc
1687
    ;;
1688
  m88k-dg-dgux*)
1689
    tentative_cc="gcc -Wall -ansi -D__using_DGUX"
1690
    ;;
1691
  m88k-harris-cxux*)
1692
    # Under CX/UX, we want to tell the compiler to use ANSI mode.
1693
    tentative_cc="cc -Xa"
1694
    host_makefile_frag="config/mh-cxux"
1695
    ;;
1696
  m88k-motorola-sysv*)
1697
    ;;
1698
  mips*-dec-ultrix*)
1699
    tentative_cc="cc -Wf,-XNg1000"
1700
    host_makefile_frag="config/mh-decstation"
1701
    ;;
1702
  mips*-nec-sysv4*)
1703
    # The C compiler on NEC MIPS SVR4 needs bigger tables.
1704
    tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
1705
    host_makefile_frag="config/mh-necv4"
1706
    ;;
1707
  mips*-sgi-irix4*)
1708
    # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
1709
    # environment.  Also bump switch table size so that cp-parse will
1710
    # compile.  Bump string length limit so linker builds.
1711
    tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
1712
    ;;
1713
  mips*-*-sysv4*)
1714
    host_makefile_frag="config/mh-sysv4"
1715
    ;;
1716
  mips*-*-sysv*)
1717
    # This is for a MIPS running RISC/os 4.52C.
1718
 
1719
    # This is needed for GDB, but needs to be in the top-level make because
1720
    # if a library is compiled with the bsd headers and gets linked with the
1721
    # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
1722
    # a different size).
1723
    # ptrace(2) apparently has problems in the BSD environment.  No workaround is
1724
    # known except to select the sysv environment.  Could we use /proc instead?
1725
    # These "sysv environments" and "bsd environments" often end up being a pain.
1726
    #
1727
    # This is not part of CFLAGS because perhaps not all C compilers have this
1728
    # option.
1729
    tentative_cc="cc -systype sysv"
1730
    ;;
1731
  i370-ibm-opened*)
1732
    tentative_cc="c89"
1733
    ;;
1734
  i[3456789]86-*-sysv5*)
1735
    host_makefile_frag="config/mh-sysv5"
1736
    ;;
1737
  i[3456789]86-*-dgux*)
1738
    tentative_cc="gcc -Wall -ansi -D__using_DGUX"
1739
    host_makefile_frag="config/mh-dgux386"
1740
    ;;
1741
  i[3456789]86-ncr-sysv4.3*)
1742
    # The MetaWare compiler will generate a copyright message unless you
1743
    # turn it off by adding the -Hnocopyr flag.
1744
    tentative_cc="cc -Hnocopyr"
1745
    ;;
1746
  i[3456789]86-ncr-sysv4*)
1747
    # for an NCR 3000 (i486/SVR4) system.
1748
    # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
1749
    # This compiler not only emits obnoxious copyright messages every time
1750
    # you run it, but it chokes and dies on a whole bunch of GNU source
1751
    # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
1752
    tentative_cc="/usr/ccs/ATT/cc"
1753
    host_makefile_frag="config/mh-ncr3000"
1754
    ;;
1755
  i[3456789]86-*-sco3.2v5*)
1756
    ;;
1757
  i[3456789]86-*-sco*)
1758
    # The native C compiler botches some simple uses of const.  Unfortunately,
1759
    # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
1760
    tentative_cc="cc -Dconst="
1761
    host_makefile_frag="config/mh-sco"
1762
    ;;
1763
  i[3456789]86-*-udk*)
1764
    host_makefile_frag="config/mh-sysv5"
1765
    ;;
1766
  i[3456789]86-*-solaris2*)
1767
    host_makefile_frag="config/mh-sysv4"
1768
    ;;
1769
  i[3456789]86-*-msdosdjgpp*)
1770
    host_makefile_frag="config/mh-djgpp"
1771
    ;;
1772
  *-cygwin*)
1773
    host_makefile_frag="config/mh-cygwin"
1774
    ;;
1775
  *-mingw32*)
1776
    ;;
1777
  *-interix*)
1778
    host_makefile_frag="config/mh-interix"
1779
    ;;
1780
  vax-*-ultrix2*)
1781
    # The old BSD pcc isn't up to compiling parts of gdb so use gcc
1782
    tentative_cc=gcc
1783
    ;;
1784
  *-*-solaris2*)
1785
    host_makefile_frag="config/mh-solaris"
1786
    ;;
1787
  m68k-sun-sunos*)
1788
    # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
1789
    # without overflowing the jump tables (-J says to use a 32 bit table)
1790
    tentative_cc="cc -J"
1791
    ;;
1792
  *-hp-hpux*)
1793
    tentative_cc="cc -Wp,-H256000"
1794
    ;;
1795
  *-*-hiux*)
1796
    tentative_cc="cc -Wp,-H256000"
1797
    ;;
1798
  rs6000-*-lynxos*)
1799
    # /bin/cc is less than useful for our purposes.  Always use GCC
1800
    tentative_cc="/usr/cygnus/progressive/bin/gcc"
1801
    host_makefile_frag="config/mh-lynxrs6k"
1802
    ;;
1803
  powerpc-*-darwin*)
1804
    host_makefile_frag="config/mh-ppc-darwin"
1805
    ;;
1806
  powerpc-*-aix*)
1807
    host_makefile_frag="config/mh-ppc-aix"
1808
    ;;
1809
  rs6000-*-aix*)
1810
    host_makefile_frag="config/mh-ppc-aix"
1811
    ;;
1812
  *-*-lynxos*)
1813
    # /bin/cc is less than useful for our purposes.  Always use GCC
1814
    tentative_cc="/bin/gcc"
1815
    ;;
1816
  *-*-sysv4*)
1817
    host_makefile_frag="config/mh-sysv4"
1818
    ;;
1819
  # This is placed last to prevent interfering with the cases above.
1820
  i[3456789]86-*-*)
1821
    # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
1822
    host_makefile_frag="config/mh-x86omitfp"
1823
    ;;
1824
esac
1825
fi
1826
 
1827
# If we aren't going to be using gcc, see if we can extract a definition
1828
# of CC from the fragment.
1829
# Actually, use the 'pre-extracted' version above.
1830
if test -z "${CC}" && test "${build}" = "${host}" ; then
1831
  IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1832
  found=
1833
  for dir in $PATH; do
1834
    test -z "$dir" && dir=.
1835
    if test -f $dir/gcc; then
1836
      found=yes
1837
      break
1838
    fi
1839
  done
1840
  IFS="$save_ifs"
1841
  if test -z "${found}" && test -n "${tentative_cc}" ; then
1842
    CC=$tentative_cc
1843
  fi
1844
fi
1845
 
1846
if test "${build}" != "${host}" ; then
1847
  # If we are doing a Canadian Cross, in which the host and build systems
1848
  # are not the same, we set reasonable default values for the tools.
1849
 
1850
  CC=${CC-${host_alias}-gcc}
1851
  CFLAGS=${CFLAGS-"-g -O2"}
1852
  CXX=${CXX-${host_alias}-c++}
1853
  CXXFLAGS=${CXXFLAGS-"-g -O2"}
1854
  CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
1855
 
1856
else
1857
  # Set reasonable default values for some tools even if not Canadian.
1858
  # Of course, these are different reasonable default values, originally
1859
  # specified directly in the Makefile.
1860
  # We don't export, so that autoconf can do its job.
1861
  # Note that all these settings are above the fragment inclusion point
1862
  # in Makefile.in, so can still be overridden by fragments.
1863
  # This is all going to change when we autoconfiscate...
1864
 
1865
  CC_FOR_BUILD="\$(CC)"
1866
  # Extract the first word of "gcc", so it can be a program name with args.
1867
set dummy gcc; ac_word=$2
1868
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1869
echo "configure:1866: checking for $ac_word" >&5
1870
if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
1871
  echo $ac_n "(cached) $ac_c" 1>&6
1872
else
1873
  if test -n "$CC"; then
1874
  ac_cv_prog_CC="$CC" # Let the user override the test.
1875
else
1876
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1877
  ac_dummy="$PATH"
1878
  for ac_dir in $ac_dummy; do
1879
    test -z "$ac_dir" && ac_dir=.
1880
    if test -f $ac_dir/$ac_word; then
1881
      ac_cv_prog_CC="gcc"
1882
      break
1883
    fi
1884
  done
1885
  IFS="$ac_save_ifs"
1886
fi
1887
fi
1888
CC="$ac_cv_prog_CC"
1889
if test -n "$CC"; then
1890
  echo "$ac_t""$CC" 1>&6
1891
else
1892
  echo "$ac_t""no" 1>&6
1893
fi
1894
 
1895
if test -z "$CC"; then
1896
  # Extract the first word of "cc", so it can be a program name with args.
1897
set dummy cc; ac_word=$2
1898
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1899
echo "configure:1896: checking for $ac_word" >&5
1900
if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
1901
  echo $ac_n "(cached) $ac_c" 1>&6
1902
else
1903
  if test -n "$CC"; then
1904
  ac_cv_prog_CC="$CC" # Let the user override the test.
1905
else
1906
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1907
  ac_prog_rejected=no
1908
  ac_dummy="$PATH"
1909
  for ac_dir in $ac_dummy; do
1910
    test -z "$ac_dir" && ac_dir=.
1911
    if test -f $ac_dir/$ac_word; then
1912
      if test "$ac_dir/$ac_word" = "/usr/ucb/cc"; then
1913
        ac_prog_rejected=yes
1914
        continue
1915
      fi
1916
      ac_cv_prog_CC="cc"
1917
      break
1918
    fi
1919
  done
1920
  IFS="$ac_save_ifs"
1921
if test $ac_prog_rejected = yes; then
1922
  # We found a bogon in the path, so make sure we never use it.
1923
  set dummy $ac_cv_prog_CC
1924
  shift
1925
  if test $# -gt 0; then
1926
    # We chose a different compiler from the bogus one.
1927
    # However, it has the same basename, so the bogon will be chosen
1928
    # first if we set CC to just the basename; use the full file name.
1929
    shift
1930
    set dummy "$ac_dir/$ac_word" "$@"
1931
    shift
1932
    ac_cv_prog_CC="$@"
1933
  fi
1934
fi
1935
fi
1936
fi
1937
CC="$ac_cv_prog_CC"
1938
if test -n "$CC"; then
1939
  echo "$ac_t""$CC" 1>&6
1940
else
1941
  echo "$ac_t""no" 1>&6
1942
fi
1943
 
1944
  if test -z "$CC"; then
1945
    case "`uname -s`" in
1946
    *win32* | *WIN32*)
1947
      # Extract the first word of "cl", so it can be a program name with args.
1948
set dummy cl; ac_word=$2
1949
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1950
echo "configure:1947: checking for $ac_word" >&5
1951
if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
1952
  echo $ac_n "(cached) $ac_c" 1>&6
1953
else
1954
  if test -n "$CC"; then
1955
  ac_cv_prog_CC="$CC" # Let the user override the test.
1956
else
1957
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1958
  ac_dummy="$PATH"
1959
  for ac_dir in $ac_dummy; do
1960
    test -z "$ac_dir" && ac_dir=.
1961
    if test -f $ac_dir/$ac_word; then
1962
      ac_cv_prog_CC="cl"
1963
      break
1964
    fi
1965
  done
1966
  IFS="$ac_save_ifs"
1967
fi
1968
fi
1969
CC="$ac_cv_prog_CC"
1970
if test -n "$CC"; then
1971
  echo "$ac_t""$CC" 1>&6
1972
else
1973
  echo "$ac_t""no" 1>&6
1974
fi
1975
 ;;
1976
    esac
1977
  fi
1978
  test -z "$CC" && { echo "configure: error: no acceptable cc found in \$PATH" 1>&2; exit 1; }
1979
fi
1980
 
1981
echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works""... $ac_c" 1>&6
1982
echo "configure:1979: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works" >&5
1983
 
1984
ac_ext=c
1985
# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
1986
ac_cpp='$CPP $CPPFLAGS'
1987
ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
1988
ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
1989
cross_compiling=$ac_cv_prog_cc_cross
1990
 
1991
cat > conftest.$ac_ext << EOF
1992
 
1993
#line 1990 "configure"
1994
#include "confdefs.h"
1995
 
1996
main(){return(0);}
1997
EOF
1998
if { (eval echo configure:1995: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
1999
  ac_cv_prog_cc_works=yes
2000
  # If we can't run a trivial program, we are probably using a cross compiler.
2001
  if (./conftest; exit) 2>/dev/null; then
2002
    ac_cv_prog_cc_cross=no
2003
  else
2004
    ac_cv_prog_cc_cross=yes
2005
  fi
2006
else
2007
  echo "configure: failed program was:" >&5
2008
  cat conftest.$ac_ext >&5
2009
  ac_cv_prog_cc_works=no
2010
fi
2011
rm -fr conftest*
2012
ac_ext=c
2013
# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2014
ac_cpp='$CPP $CPPFLAGS'
2015
ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2016
ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2017
cross_compiling=$ac_cv_prog_cc_cross
2018
 
2019
echo "$ac_t""$ac_cv_prog_cc_works" 1>&6
2020
if test $ac_cv_prog_cc_works = no; then
2021
  { echo "configure: error: installation or configuration problem: C compiler cannot create executables." 1>&2; exit 1; }
2022
fi
2023
echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler""... $ac_c" 1>&6
2024
echo "configure:2021: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler" >&5
2025
echo "$ac_t""$ac_cv_prog_cc_cross" 1>&6
2026
cross_compiling=$ac_cv_prog_cc_cross
2027
 
2028
echo $ac_n "checking whether we are using GNU C""... $ac_c" 1>&6
2029
echo "configure:2026: checking whether we are using GNU C" >&5
2030
if eval "test \"`echo '$''{'ac_cv_prog_gcc'+set}'`\" = set"; then
2031
  echo $ac_n "(cached) $ac_c" 1>&6
2032
else
2033
  cat > conftest.c <
2034
#ifdef __GNUC__
2035
  yes;
2036
#endif
2037
EOF
2038
if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:2035: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
2039
  ac_cv_prog_gcc=yes
2040
else
2041
  ac_cv_prog_gcc=no
2042
fi
2043
fi
2044
 
2045
echo "$ac_t""$ac_cv_prog_gcc" 1>&6
2046
 
2047
if test $ac_cv_prog_gcc = yes; then
2048
  GCC=yes
2049
else
2050
  GCC=
2051
fi
2052
 
2053
ac_test_CFLAGS="${CFLAGS+set}"
2054
ac_save_CFLAGS="$CFLAGS"
2055
CFLAGS=
2056
echo $ac_n "checking whether ${CC-cc} accepts -g""... $ac_c" 1>&6
2057
echo "configure:2054: checking whether ${CC-cc} accepts -g" >&5
2058
if eval "test \"`echo '$''{'ac_cv_prog_cc_g'+set}'`\" = set"; then
2059
  echo $ac_n "(cached) $ac_c" 1>&6
2060
else
2061
  echo 'void f(){}' > conftest.c
2062
if test -z "`${CC-cc} -g -c conftest.c 2>&1`"; then
2063
  ac_cv_prog_cc_g=yes
2064
else
2065
  ac_cv_prog_cc_g=no
2066
fi
2067
rm -f conftest*
2068
 
2069
fi
2070
 
2071
echo "$ac_t""$ac_cv_prog_cc_g" 1>&6
2072
if test "$ac_test_CFLAGS" = set; then
2073
  CFLAGS="$ac_save_CFLAGS"
2074
elif test $ac_cv_prog_cc_g = yes; then
2075
  if test "$GCC" = yes; then
2076
    CFLAGS="-g -O2"
2077
  else
2078
    CFLAGS="-g"
2079
  fi
2080
else
2081
  if test "$GCC" = yes; then
2082
    CFLAGS="-O2"
2083
  else
2084
    CFLAGS=
2085
  fi
2086
fi
2087
 
2088
 
2089
  # We must set the default linker to the linker used by gcc for the correct
2090
  # operation of libtool.  If LD is not defined and we are using gcc, try to
2091
  # set the LD default to the ld used by gcc.
2092
  if test -z "$LD"; then
2093
    if test "$GCC" = yes; then
2094
      case $build in
2095
      *-*-mingw*)
2096
        gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
2097
      *)
2098
        gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
2099
      esac
2100
      case $gcc_prog_ld in
2101
      # Accept absolute paths.
2102
      [\\/]* | [A-Za-z]:[\\/]*)
2103
        LD="$gcc_prog_ld" ;;
2104
      esac
2105
    fi
2106
  fi
2107
 
2108
  CXX=${CXX-"c++"}
2109
  CFLAGS=${CFLAGS-"-g"}
2110
  CXXFLAGS=${CXXFLAGS-"-g -O2"}
2111
fi
2112
 
2113
if test $host != $build; then
2114
  ac_tool_prefix=${host_alias}-
2115
else
2116
  ac_tool_prefix=
2117
fi
2118
 
2119
 
2120
 
2121
# Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
2122
set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
2123
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
2124
echo "configure:2121: checking for $ac_word" >&5
2125
if eval "test \"`echo '$''{'ac_cv_prog_GNATBIND'+set}'`\" = set"; then
2126
  echo $ac_n "(cached) $ac_c" 1>&6
2127
else
2128
  if test -n "$GNATBIND"; then
2129
  ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
2130
else
2131
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
2132
  ac_dummy="$PATH"
2133
  for ac_dir in $ac_dummy; do
2134
    test -z "$ac_dir" && ac_dir=.
2135
    if test -f $ac_dir/$ac_word; then
2136
      ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
2137
      break
2138
    fi
2139
  done
2140
  IFS="$ac_save_ifs"
2141
fi
2142
fi
2143
GNATBIND="$ac_cv_prog_GNATBIND"
2144
if test -n "$GNATBIND"; then
2145
  echo "$ac_t""$GNATBIND" 1>&6
2146
else
2147
  echo "$ac_t""no" 1>&6
2148
fi
2149
 
2150
 
2151
if test -z "$ac_cv_prog_GNATBIND"; then
2152
if test -n "$ac_tool_prefix"; then
2153
  # Extract the first word of "gnatbind", so it can be a program name with args.
2154
set dummy gnatbind; ac_word=$2
2155
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
2156
echo "configure:2153: checking for $ac_word" >&5
2157
if eval "test \"`echo '$''{'ac_cv_prog_GNATBIND'+set}'`\" = set"; then
2158
  echo $ac_n "(cached) $ac_c" 1>&6
2159
else
2160
  if test -n "$GNATBIND"; then
2161
  ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
2162
else
2163
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
2164
  ac_dummy="$PATH"
2165
  for ac_dir in $ac_dummy; do
2166
    test -z "$ac_dir" && ac_dir=.
2167
    if test -f $ac_dir/$ac_word; then
2168
      ac_cv_prog_GNATBIND="gnatbind"
2169
      break
2170
    fi
2171
  done
2172
  IFS="$ac_save_ifs"
2173
  test -z "$ac_cv_prog_GNATBIND" && ac_cv_prog_GNATBIND="no"
2174
fi
2175
fi
2176
GNATBIND="$ac_cv_prog_GNATBIND"
2177
if test -n "$GNATBIND"; then
2178
  echo "$ac_t""$GNATBIND" 1>&6
2179
else
2180
  echo "$ac_t""no" 1>&6
2181
fi
2182
 
2183
else
2184
  GNATBIND="no"
2185
fi
2186
fi
2187
 
2188
echo $ac_n "checking whether compiler driver understands Ada""... $ac_c" 1>&6
2189
echo "configure:2186: checking whether compiler driver understands Ada" >&5
2190
if eval "test \"`echo '$''{'acx_cv_cc_gcc_supports_ada'+set}'`\" = set"; then
2191
  echo $ac_n "(cached) $ac_c" 1>&6
2192
else
2193
  cat >conftest.adb <
2194
procedure conftest is begin null; end conftest;
2195
EOF
2196
acx_cv_cc_gcc_supports_ada=no
2197
# There is a bug in old released versions of GCC which causes the
2198
# driver to exit successfully when the appropriate language module
2199
# has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
2200
# Therefore we must check for the error message as well as an
2201
# unsuccessful exit.
2202
# Other compilers, like HP Tru64 UNIX cc, exit successfully when
2203
# given a .adb file, but produce no object file.  So we must check
2204
# if an object file was really produced to guard against this.
2205
errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
2206
if test x"$errors" = x && test -f conftest.$ac_objext; then
2207
  acx_cv_cc_gcc_supports_ada=yes
2208
fi
2209
rm -f conftest.*
2210
fi
2211
 
2212
echo "$ac_t""$acx_cv_cc_gcc_supports_ada" 1>&6
2213
 
2214
if test x$GNATBIND != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
2215
  have_gnat=yes
2216
else
2217
  have_gnat=no
2218
fi
2219
 
2220
echo $ac_n "checking how to compare bootstrapped objects""... $ac_c" 1>&6
2221
echo "configure:2218: checking how to compare bootstrapped objects" >&5
2222
if eval "test \"`echo '$''{'gcc_cv_prog_cmp_skip'+set}'`\" = set"; then
2223
  echo $ac_n "(cached) $ac_c" 1>&6
2224
else
2225
   echo abfoo >t1
2226
  echo cdfoo >t2
2227
  gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
2228
  if cmp t1 t2 2 2 > /dev/null 2>&1; then
2229
    if cmp t1 t2 1 1 > /dev/null 2>&1; then
2230
      :
2231
    else
2232
      gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
2233
    fi
2234
  fi
2235
  if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
2236
    if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
2237
      :
2238
    else
2239
      gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
2240
    fi
2241
  fi
2242
  rm t1 t2
2243
 
2244
fi
2245
 
2246
echo "$ac_t""$gcc_cv_prog_cmp_skip" 1>&6
2247
do_compare="$gcc_cv_prog_cmp_skip"
2248
 
2249
 
2250
 
2251
# Check for GMP and MPFR
2252
gmplibs="-lmpfr"
2253
gmpinc=
2254
have_gmp=yes
2255
# Specify a location for mpfr
2256
# check for this first so it ends up on the link line before gmp.
2257
# Check whether --with-mpfr-dir or --without-mpfr-dir was given.
2258
if test "${with_mpfr_dir+set}" = set; then
2259
  withval="$with_mpfr_dir"
2260
  { echo "configure: error: The --with-mpfr-dir=PATH option has been removed.
2261
Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" 1>&2; exit 1; }
2262
fi
2263
 
2264
 
2265
# Check whether --with-mpfr or --without-mpfr was given.
2266
if test "${with_mpfr+set}" = set; then
2267
  withval="$with_mpfr"
2268
  :
2269
fi
2270
 
2271
# Check whether --with-mpfr_include or --without-mpfr_include was given.
2272
if test "${with_mpfr_include+set}" = set; then
2273
  withval="$with_mpfr_include"
2274
  :
2275
fi
2276
 
2277
# Check whether --with-mpfr_lib or --without-mpfr_lib was given.
2278
if test "${with_mpfr_lib+set}" = set; then
2279
  withval="$with_mpfr_lib"
2280
  :
2281
fi
2282
 
2283
 
2284
if test "x$with_mpfr" != x; then
2285
  gmplibs="-L$with_mpfr/lib $gmplibs"
2286
  gmpinc="-I$with_mpfr/include"
2287
fi
2288
if test "x$with_mpfr_include" != x; then
2289
  gmpinc="-I$with_mpfr_include"
2290
fi
2291
if test "x$with_mpfr_lib" != x; then
2292
  gmplibs="-L$with_mpfr_lib $gmplibs"
2293
fi
2294
 
2295
# Specify a location for gmp
2296
# Check whether --with-gmp-dir or --without-gmp-dir was given.
2297
if test "${with_gmp_dir+set}" = set; then
2298
  withval="$with_gmp_dir"
2299
  { echo "configure: error: The --with-gmp-dir=PATH option has been removed.
2300
Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" 1>&2; exit 1; }
2301
fi
2302
 
2303
 
2304
gmplibs="$gmplibs -lgmp"
2305
 
2306
# Check whether --with-gmp or --without-gmp was given.
2307
if test "${with_gmp+set}" = set; then
2308
  withval="$with_gmp"
2309
  :
2310
fi
2311
 
2312
# Check whether --with-gmp_include or --without-gmp_include was given.
2313
if test "${with_gmp_include+set}" = set; then
2314
  withval="$with_gmp_include"
2315
  :
2316
fi
2317
 
2318
# Check whether --with-gmp_lib or --without-gmp_lib was given.
2319
if test "${with_gmp_lib+set}" = set; then
2320
  withval="$with_gmp_lib"
2321
  :
2322
fi
2323
 
2324
 
2325
 
2326
if test "x$with_gmp" != x; then
2327
  gmplibs="-L$with_gmp/lib $gmplibs"
2328
  gmpinc="-I$with_gmp/include $gmpinc"
2329
fi
2330
if test "x$with_gmp_include" != x; then
2331
  gmpinc="-I$with_gmp_include $gmpinc"
2332
fi
2333
if test "x$with_gmp_lib" != x; then
2334
  gmplibs="-L$with_gmp_lib $gmplibs"
2335
fi
2336
 
2337
saved_CFLAGS="$CFLAGS"
2338
CFLAGS="$CFLAGS $gmpinc"
2339
# Check GMP actually works
2340
echo $ac_n "checking for correct version of gmp.h""... $ac_c" 1>&6
2341
echo "configure:2338: checking for correct version of gmp.h" >&5
2342
cat > conftest.$ac_ext <
2343
#line 2340 "configure"
2344
#include "confdefs.h"
2345
#include "gmp.h"
2346
int main() {
2347
 
2348
#if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
2349
choke me
2350
#endif
2351
 
2352
; return 0; }
2353
EOF
2354
if { (eval echo configure:2351: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
2355
  rm -rf conftest*
2356
  echo "$ac_t""yes" 1>&6
2357
else
2358
  echo "configure: failed program was:" >&5
2359
  cat conftest.$ac_ext >&5
2360
  rm -rf conftest*
2361
  echo "$ac_t""no" 1>&6; have_gmp=no
2362
fi
2363
rm -f conftest*
2364
 
2365
if test x"$have_gmp" = xyes; then
2366
  echo $ac_n "checking for correct version of mpfr.h""... $ac_c" 1>&6
2367
echo "configure:2364: checking for correct version of mpfr.h" >&5
2368
  cat > conftest.$ac_ext <
2369
#line 2366 "configure"
2370
#include "confdefs.h"
2371
#include "gmp.h"
2372
#include 
2373
int main() {
2374
 
2375
#if MPFR_VERSION < MPFR_VERSION_NUM(2,2,1)
2376
  choke me
2377
#endif
2378
 
2379
; return 0; }
2380
EOF
2381
if { (eval echo configure:2378: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
2382
  rm -rf conftest*
2383
  echo "$ac_t""yes" 1>&6
2384
else
2385
  echo "configure: failed program was:" >&5
2386
  cat conftest.$ac_ext >&5
2387
  rm -rf conftest*
2388
  echo "$ac_t""buggy version of MPFR detected" 1>&6
2389
fi
2390
rm -f conftest*
2391
 
2392
  saved_LIBS="$LIBS"
2393
  LIBS="$LIBS $gmplibs"
2394
  echo $ac_n "checking for any version of mpfr.h""... $ac_c" 1>&6
2395
echo "configure:2392: checking for any version of mpfr.h" >&5
2396
  cat > conftest.$ac_ext <
2397
#line 2394 "configure"
2398
#include "confdefs.h"
2399
#include 
2400
#include 
2401
int main() {
2402
mpfr_t n; mpfr_init(n);
2403
; return 0; }
2404
EOF
2405
if { (eval echo configure:2402: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
2406
  rm -rf conftest*
2407
  echo "$ac_t""yes" 1>&6
2408
else
2409
  echo "configure: failed program was:" >&5
2410
  cat conftest.$ac_ext >&5
2411
  rm -rf conftest*
2412
  echo "$ac_t""no" 1>&6; have_gmp=no
2413
fi
2414
rm -f conftest*
2415
  LIBS="$saved_LIBS"
2416
fi
2417
CFLAGS="$saved_CFLAGS"
2418
 
2419
# Flags needed for both GMP and/or MPFR
2420
 
2421
 
2422
 
2423
# By default, C is the only stage 1 language.
2424
stage1_languages=c
2425
 
2426
 
2427
# Figure out what language subdirectories are present.
2428
# Look if the user specified --enable-languages="..."; if not, use
2429
# the environment variable $LANGUAGES if defined. $LANGUAGES might
2430
# go away some day.
2431
# NB:  embedded tabs in this IF block -- do not untabify
2432
if test -d ${srcdir}/gcc; then
2433
  if test x"${enable_languages+set}" != xset; then
2434
    if test x"${LANGUAGES+set}" = xset; then
2435
      enable_languages="${LANGUAGES}"
2436
        echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
2437
    else
2438
      enable_languages=all
2439
    fi
2440
  else
2441
    if test x"${enable_languages}" = x ||
2442
       test x"${enable_languages}" = xyes;
2443
       then
2444
      echo configure.in: --enable-languages needs at least one language argument 1>&2
2445
      exit 1
2446
    fi
2447
  fi
2448
  enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
2449
 
2450
  # 'f95' is the old name for the 'fortran' language. We issue a warning
2451
  # and make the substitution.
2452
  case ,${enable_languages}, in
2453
    *,f95,*)
2454
      echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
2455
      enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
2456
      ;;
2457
  esac
2458
 
2459
  # First scan to see if an enabled language requires some other language.
2460
  # We assume that a given config-lang.in will list all the language
2461
  # front ends it requires, even if some are required indirectly.
2462
  for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
2463
    case ${lang_frag} in
2464
      ..) ;;
2465
      # The odd quoting in the next line works around
2466
      # an apparent bug in bash 1.12 on linux.
2467
      ${srcdir}/gcc/[*]/config-lang.in) ;;
2468
      *)
2469
        # From the config-lang.in, get $language, $lang_requires
2470
        language=
2471
        lang_requires=
2472
        . ${lang_frag}
2473
        for other in ${lang_requires} ; do
2474
          case ,${enable_languages}, in
2475
            *,$other,*) ;;
2476
            *,all,*) ;;
2477
            *,$language,*)
2478
              echo " \`$other' language required by \`$language'; enabling" 1>&2
2479
              enable_languages="${enable_languages},${other}"
2480
              ;;
2481
          esac
2482
        done
2483
        ;;
2484
    esac
2485
  done
2486
 
2487
  new_enable_languages=c
2488
  missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
2489
  potential_languages=c
2490
 
2491
  for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
2492
    case ${lang_frag} in
2493
      ..) ;;
2494
      # The odd quoting in the next line works around
2495
      # an apparent bug in bash 1.12 on linux.
2496
      ${srcdir}/gcc/[*]/config-lang.in) ;;
2497
      *)
2498
        # From the config-lang.in, get $language, $target_libs,
2499
        # $lang_dirs, $boot_language, and $build_by_default
2500
        language=
2501
        target_libs=
2502
        lang_dirs=
2503
        subdir_requires=
2504
        boot_language=
2505
        build_by_default=
2506
        need_gmp=
2507
        . ${lang_frag}
2508
        potential_languages="${potential_languages},${language}"
2509
        # This is quite sensitive to the ordering of the case statement arms.
2510
        case ,${enable_languages},:${language}:${have_gnat}:${build_by_default} in
2511
          *::*:*)
2512
            echo "${lang_frag} doesn't set \$language." 1>&2
2513
            exit 1
2514
            ;;
2515
          *:ada:no:*)
2516
            # Ada was requested with no preexisting GNAT.  Disable unconditionally.
2517
            add_this_lang=no
2518
            ;;
2519
          *,${language},*:*:*:*)
2520
            # Language was explicitly selected; include it.
2521
            add_this_lang=yes
2522
            ;;
2523
          *,all,*:*:*:no)
2524
            # 'all' was selected, but this is not a default language
2525
            # so do not include it.
2526
            add_this_lang=no
2527
            ;;
2528
          *,all,*:*:*:*)
2529
            # 'all' was selected and this is a default language; include it.
2530
            add_this_lang=yes
2531
            ;;
2532
          *)
2533
            add_this_lang=no
2534
            ;;
2535
        esac
2536
 
2537
        # Disable languages that need other directories if these aren't available.
2538
        for i in $subdir_requires; do
2539
          test -f "$srcdir/gcc/$i/config-lang.in" && continue
2540
          case ,${enable_languages}, in
2541
            *,${language},*)
2542
              # Specifically requested language; tell them.
2543
              { echo "configure: error: The gcc/$i directory contains parts of $language but is missing" 1>&2; exit 1; }
2544
              ;;
2545
            *)
2546
              # Silently disable.
2547
              add_this_lang=no
2548
              ;;
2549
          esac
2550
        done
2551
 
2552
        # Disable languages that need GMP if it isn't available.
2553
        case ,${enable_languages},:${have_gmp}:${need_gmp} in
2554
          *,${language},*:no:yes)
2555
            # Specifically requested language; tell them.
2556
            { echo "configure: error: GMP 4.1 and MPFR 2.2.1 or newer versions required by $language" 1>&2; exit 1; }
2557
            ;;
2558
          *:no:yes)
2559
            # Silently disable.
2560
            add_this_lang=no
2561
            ;;
2562
        esac
2563
 
2564
        # Disable a language that is unsupported by the target.
2565
        case " $unsupported_languages " in
2566
          *" $language "*)
2567
            add_this_lang=no
2568
            ;;
2569
        esac
2570
 
2571
        case $add_this_lang in
2572
          no)
2573
            # Remove language-dependent dirs.
2574
            eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
2575
            ;;
2576
          *)
2577
            new_enable_languages="$new_enable_languages,$language"
2578
            missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
2579
            case ${boot_language} in
2580
              yes)
2581
                # Add to (comma-separated) list of stage 1 languages.
2582
                stage1_languages="${stage1_languages},${language}"
2583
                ;;
2584
            esac
2585
            ;;
2586
        esac
2587
        ;;
2588
    esac
2589
  done
2590
 
2591
  missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
2592
  if test "x$missing_languages" != x; then
2593
    { echo "configure: error:
2594
The following requested languages could not be built: ${missing_languages}
2595
Recognised languages are: ${potential_languages}" 1>&2; exit 1; }
2596
  fi
2597
 
2598
  if test "x$new_enable_languages" != "x$enable_languages"; then
2599
    echo The following languages will be built: ${new_enable_languages}
2600
  fi
2601
  enable_languages="$new_enable_languages"
2602
  ac_configure_args=`echo " $ac_configure_args" | sed -e 's/ --enable-languages=[^ ]*//' -e 's/$/ --enable-languages='"$enable_languages"/ `
2603
fi
2604
 
2605
# Handle --disable- generically.
2606
for dir in $configdirs $build_configdirs $target_configdirs ; do
2607
  dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
2608
  if eval test x\${enable_${dirname}} "=" xno ; then
2609
    noconfigdirs="$noconfigdirs $dir"
2610
  fi
2611
done
2612
 
2613
# Check for Boehm's garbage collector
2614
# Check whether --enable-objc-gc or --disable-objc-gc was given.
2615
if test "${enable_objc_gc+set}" = set; then
2616
  enableval="$enable_objc_gc"
2617
  case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
2618
  *,objc,*:*:yes:*target-boehm-gc*)
2619
    { echo "configure: error: Boehm's garbage collector was requested yet not supported in this configuration" 1>&2; exit 1; }
2620
    ;;
2621
esac
2622
fi
2623
 
2624
 
2625
# Make sure we only build Boehm's garbage collector if required.
2626
case ,${enable_languages},:${enable_objc_gc} in
2627
  *,objc,*:yes)
2628
    # Keep target-boehm-gc if requested for Objective-C.
2629
    ;;
2630
  *)
2631
    # Otherwise remove target-boehm-gc depending on target-libjava.
2632
    if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
2633
      noconfigdirs="$noconfigdirs target-boehm-gc"
2634
    fi
2635
    ;;
2636
esac
2637
 
2638
# Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
2639
# $build_configdirs and $target_configdirs.
2640
# If we have the source for $noconfigdirs entries, add them to $notsupp.
2641
 
2642
notsupp=""
2643
for dir in . $skipdirs $noconfigdirs ; do
2644
  dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
2645
  if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
2646
    configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
2647
    if test -r $srcdir/$dirname/configure ; then
2648
      if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
2649
        true
2650
      else
2651
        notsupp="$notsupp $dir"
2652
      fi
2653
    fi
2654
  fi
2655
  if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
2656
    build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
2657
    if test -r $srcdir/$dirname/configure ; then
2658
      if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
2659
        true
2660
      else
2661
        notsupp="$notsupp $dir"
2662
      fi
2663
    fi
2664
  fi
2665
  if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
2666
    target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
2667
    if test -r $srcdir/$dirname/configure ; then
2668
      if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
2669
        true
2670
      else
2671
        notsupp="$notsupp $dir"
2672
      fi
2673
    fi
2674
  fi
2675
done
2676
 
2677
# Sometimes the tools are distributed with libiberty but with no other
2678
# libraries.  In that case, we don't want to build target-libiberty.
2679
if test -n "${target_configdirs}" ; then
2680
  others=
2681
  for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
2682
    if test "$i" != "libiberty" ; then
2683
      if test -r $srcdir/$i/configure ; then
2684
        others=yes;
2685
        break;
2686
      fi
2687
    fi
2688
  done
2689
  if test -z "${others}" ; then
2690
    target_configdirs=
2691
  fi
2692
fi
2693
 
2694
# Quietly strip out all directories which aren't configurable in this tree.
2695
# This relies on all configurable subdirectories being autoconfiscated, which
2696
# is now the case.
2697
build_configdirs_all="$build_configdirs"
2698
build_configdirs=
2699
for i in ${build_configdirs_all} ; do
2700
  j=`echo $i | sed -e s/build-//g`
2701
  if test -f ${srcdir}/$j/configure ; then
2702
    build_configdirs="${build_configdirs} $i"
2703
  fi
2704
done
2705
 
2706
configdirs_all="$configdirs"
2707
configdirs=
2708
for i in ${configdirs_all} ; do
2709
  if test -f ${srcdir}/$i/configure ; then
2710
    configdirs="${configdirs} $i"
2711
  fi
2712
done
2713
 
2714
target_configdirs_all="$target_configdirs"
2715
target_configdirs=
2716
for i in ${target_configdirs_all} ; do
2717
  j=`echo $i | sed -e s/target-//g`
2718
  if test -f ${srcdir}/$j/configure ; then
2719
    target_configdirs="${target_configdirs} $i"
2720
  fi
2721
done
2722
 
2723
# Produce a warning message for the subdirs we can't configure.
2724
# This isn't especially interesting in the Cygnus tree, but in the individual
2725
# FSF releases, it's important to let people know when their machine isn't
2726
# supported by the one or two programs in a package.
2727
 
2728
if test -n "${notsupp}" && test -z "${norecursion}" ; then
2729
  # If $appdirs is non-empty, at least one of those directories must still
2730
  # be configured, or we error out.  (E.g., if the gas release supports a
2731
  # specified target in some subdirs but not the gas subdir, we shouldn't
2732
  # pretend that all is well.)
2733
  if test -n "$appdirs" ; then
2734
    for dir in $appdirs ; do
2735
      if test -r $dir/Makefile.in ; then
2736
        if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
2737
          appdirs=""
2738
          break
2739
        fi
2740
        if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
2741
          appdirs=""
2742
          break
2743
        fi
2744
      fi
2745
    done
2746
    if test -n "$appdirs" ; then
2747
      echo "*** This configuration is not supported by this package." 1>&2
2748
      exit 1
2749
    fi
2750
  fi
2751
  # Okay, some application will build, or we don't care to check.  Still
2752
  # notify of subdirs not getting built.
2753
  echo "*** This configuration is not supported in the following subdirectories:" 1>&2
2754
  echo "    ${notsupp}" 1>&2
2755
  echo "    (Any other directories should still work fine.)" 1>&2
2756
fi
2757
 
2758
case "$host" in
2759
  *msdosdjgpp*)
2760
    enable_gdbtk=no ;;
2761
esac
2762
 
2763
copy_dirs=
2764
 
2765
# Check whether --with-build-sysroot or --without-build-sysroot was given.
2766
if test "${with_build_sysroot+set}" = set; then
2767
  withval="$with_build_sysroot"
2768
  if test x"$withval" != x ; then
2769
     SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
2770
   fi
2771
else
2772
  SYSROOT_CFLAGS_FOR_TARGET=
2773
fi
2774
 
2775
 
2776
 
2777
# Handle --with-headers=XXX.  If the value is not "yes", the contents of
2778
# the named directory are copied to $(tooldir)/sys-include.
2779
if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
2780
  if test x${is_cross_compiler} = xno ; then
2781
    echo 1>&2 '***' --with-headers is only supported when cross compiling
2782
    exit 1
2783
  fi
2784
  if test x"${with_headers}" != xyes ; then
2785
    case "${exec_prefixoption}" in
2786
    "") x=${prefix} ;;
2787
    *) x=${exec_prefix} ;;
2788
    esac
2789
    copy_dirs="${copy_dirs} ${with_headers} $x/${target_alias}/sys-include"
2790
  fi
2791
fi
2792
 
2793
# Handle --with-libs=XXX.  If the value is not "yes", the contents of
2794
# the name directories are copied to $(tooldir)/lib.  Multiple directories
2795
# are permitted.
2796
if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
2797
  if test x${is_cross_compiler} = xno ; then
2798
    echo 1>&2 '***' --with-libs is only supported when cross compiling
2799
    exit 1
2800
  fi
2801
  if test x"${with_libs}" != xyes ; then
2802
    # Copy the libraries in reverse order, so that files in the first named
2803
    # library override files in subsequent libraries.
2804
    case "${exec_prefixoption}" in
2805
    "") x=${prefix} ;;
2806
    *) x=${exec_prefix} ;;
2807
    esac
2808
    for l in ${with_libs}; do
2809
      copy_dirs="$l $x/${target_alias}/lib ${copy_dirs}"
2810
    done
2811
  fi
2812
fi
2813
 
2814
# Set with_gnu_as and with_gnu_ld as appropriate.
2815
#
2816
# This is done by determining whether or not the appropriate directory
2817
# is available, and by checking whether or not specific configurations
2818
# have requested that this magic not happen.
2819
#
2820
# The command line options always override the explicit settings in
2821
# configure.in, and the settings in configure.in override this magic.
2822
#
2823
# If the default for a toolchain is to use GNU as and ld, and you don't
2824
# want to do that, then you should use the --without-gnu-as and
2825
# --without-gnu-ld options for the configure script.
2826
 
2827
if test x${use_gnu_as} = x &&
2828
   echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
2829
  with_gnu_as=yes
2830
  extra_host_args="$extra_host_args --with-gnu-as"
2831
fi
2832
 
2833
if test x${use_gnu_ld} = x &&
2834
   echo " ${configdirs} " | grep " ld " > /dev/null 2>&1 ; then
2835
  with_gnu_ld=yes
2836
  extra_host_args="$extra_host_args --with-gnu-ld"
2837
fi
2838
 
2839
# If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
2840
# can detect this case.
2841
 
2842
if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
2843
  with_newlib=yes
2844
  extra_host_args="$extra_host_args --with-newlib"
2845
fi
2846
 
2847
# Handle ${copy_dirs}
2848
set fnord ${copy_dirs}
2849
shift
2850
while test $# != 0 ; do
2851
  if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
2852
    :
2853
  else
2854
    echo Copying $1 to $2
2855
 
2856
    # Use the install script to create the directory and all required
2857
    # parent directories.
2858
    if test -d $2 ; then
2859
      :
2860
    else
2861
      echo >config.temp
2862
      ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
2863
    fi
2864
 
2865
    # Copy the directory, assuming we have tar.
2866
    # FIXME: Should we use B in the second tar?  Not all systems support it.
2867
    (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
2868
 
2869
    # It is the responsibility of the user to correctly adjust all
2870
    # symlinks.  If somebody can figure out how to handle them correctly
2871
    # here, feel free to add the code.
2872
 
2873
    echo $1 > $2/COPIED
2874
  fi
2875
  shift; shift
2876
done
2877
 
2878
# Determine a target-dependent exec_prefix that the installed
2879
# gcc will search in.  Keep this list sorted by triplet, with
2880
# the *-*-osname triplets last.
2881
md_exec_prefix=
2882
case "${target}" in
2883
  alpha*-*-*vms*)
2884
    md_exec_prefix=/gnu/lib/gcc-lib
2885
    ;;
2886
  i3456786-pc-msdosdjgpp*)
2887
    md_exec_prefix=/dev/env/DJDIR/bin
2888
    ;;
2889
  i3456786-*-sco3.2v5*)
2890
    if test $with_gnu_as = yes; then
2891
      md_exec_prefix=/usr/gnu/bin
2892
    else
2893
      md_exec_prefix=/usr/ccs/bin/elf
2894
    fi
2895
    ;;
2896
 
2897
  mn10300-*-* | \
2898
  powerpc-*-chorusos* | \
2899
  powerpc*-*-eabi* | \
2900
  powerpc*-*-sysv* | \
2901
  powerpc*-*-kaos* | \
2902
  s390x-ibm-tpf*)
2903
    md_exec_prefix=/usr/ccs/bin
2904
    ;;
2905
  sparc64-*-elf*)
2906
    ;;
2907
  v850*-*-*)
2908
    md_exec_prefix=/usr/ccs/bin
2909
    ;;
2910
  xtensa-*-elf*)
2911
    ;;
2912
 
2913
  *-*-beos* | \
2914
  *-*-elf* | \
2915
  *-*-hpux* | \
2916
  *-*-netware* | \
2917
  *-*-nto-qnx* | \
2918
  *-*-rtems* | \
2919
  *-*-solaris2* | \
2920
  *-*-sysv45* | \
2921
  *-*-vxworks* | \
2922
  *-wrs-windiss)
2923
    md_exec_prefix=/usr/ccs/bin
2924
    ;;
2925
esac
2926
 
2927
extra_arflags_for_target=
2928
extra_nmflags_for_target=
2929
extra_ranlibflags_for_target=
2930
target_makefile_frag=/dev/null
2931
case "${target}" in
2932
  *-*-netware*)
2933
    target_makefile_frag="config/mt-netware"
2934
    ;;
2935
  *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2936
    target_makefile_frag="config/mt-gnu"
2937
    ;;
2938
  *-*-aix4.[3456789]* | *-*-aix[56789].*)
2939
    # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
2940
    # commands to handle both 32-bit and 64-bit objects.  These flags are
2941
    # harmless if we're using GNU nm or ar.
2942
    extra_arflags_for_target=" -X32_64"
2943
    extra_nmflags_for_target=" -B -X32_64"
2944
    ;;
2945
  *-*-darwin*)
2946
    # ranlib from Darwin requires the -c flag to look at common symbols.
2947
    extra_ranlibflags_for_target=" -c"
2948
    ;;
2949
  mips*-*-pe | sh*-*-pe | *arm-wince-pe)
2950
    target_makefile_frag="config/mt-wince"
2951
    ;;
2952
esac
2953
 
2954
alphaieee_frag=/dev/null
2955
case $target in
2956
  alpha*-*-*)
2957
    # This just makes sure to use the -mieee option to build target libs.
2958
    # This should probably be set individually by each library.
2959
    alphaieee_frag="config/mt-alphaieee"
2960
    ;;
2961
esac
2962
 
2963
# If --enable-target-optspace always use -Os instead of -O2 to build
2964
# the target libraries, similarly if it is not specified, use -Os
2965
# on selected platforms.
2966
ospace_frag=/dev/null
2967
case "${enable_target_optspace}:${target}" in
2968
  yes:*)
2969
    ospace_frag="config/mt-ospace"
2970
    ;;
2971
  :d30v-*)
2972
    ospace_frag="config/mt-d30v"
2973
    ;;
2974
  :m32r-* | :d10v-* | :fr30-*)
2975
    ospace_frag="config/mt-ospace"
2976
    ;;
2977
  no:* | :*)
2978
    ;;
2979
  *)
2980
    echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
2981
    ;;
2982
esac
2983
 
2984
# Default to using --with-stabs for certain targets.
2985
if test x${with_stabs} = x ; then
2986
  case "${target}" in
2987
  mips*-*-irix[56]*)
2988
    ;;
2989
  mips*-*-* | alpha*-*-osf*)
2990
    with_stabs=yes;
2991
    extra_host_args="${extra_host_args} --with-stabs"
2992
    ;;
2993
  esac
2994
fi
2995
 
2996
# hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
2997
# them automatically.
2998
case "${host}" in
2999
  hppa*64*-*-hpux11*)
3000
    extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
3001
    ;;
3002
esac
3003
 
3004
# Some systems (e.g., one of the i386-aix systems the gas testers are
3005
# using) don't handle "\$" correctly, so don't use it here.
3006
tooldir='${exec_prefix}'/${target_alias}
3007
build_tooldir=${tooldir}
3008
 
3009
# Create a .gdbinit file which runs the one in srcdir
3010
# and tells GDB to look there for source files.
3011
 
3012
if test -r ${srcdir}/.gdbinit ; then
3013
  case ${srcdir} in
3014
    .) ;;
3015
    *) cat > ./.gdbinit <
3016
# ${NO_EDIT}
3017
dir ${srcdir}
3018
dir .
3019
source ${srcdir}/.gdbinit
3020
EOF
3021
    ;;
3022
  esac
3023
fi
3024
 
3025
# Make sure that the compiler is able to generate an executable.  If it
3026
# can't, we are probably in trouble.  We don't care whether we can run the
3027
# executable--we might be using a cross compiler--we only care whether it
3028
# can be created.  At this point the main configure script has set CC.
3029
we_are_ok=no
3030
echo "int main () { return 0; }" > conftest.c
3031
${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
3032
if test $? = 0 ; then
3033
  if test -s conftest || test -s conftest.exe ; then
3034
    we_are_ok=yes
3035
  fi
3036
fi
3037
case $we_are_ok in
3038
  no)
3039
    echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
3040
    echo 1>&2 "*** You must set the environment variable CC to a working compiler."
3041
    rm -f conftest*
3042
    exit 1
3043
    ;;
3044
esac
3045
rm -f conftest*
3046
 
3047
# The Solaris /usr/ucb/cc compiler does not appear to work.
3048
case "${host}" in
3049
  sparc-sun-solaris2*)
3050
      CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
3051
      if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
3052
          could_use=
3053
          test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
3054
          if test -d /opt/cygnus/bin ; then
3055
              if test "$could_use" = "" ; then
3056
                  could_use="/opt/cygnus/bin"
3057
              else
3058
                  could_use="$could_use or /opt/cygnus/bin"
3059
              fi
3060
          fi
3061
        if test "$could_use" = "" ; then
3062
            echo "Warning: compilation may fail because you're using"
3063
            echo "/usr/ucb/cc.  You should change your PATH or CC "
3064
            echo "variable and rerun configure."
3065
        else
3066
            echo "Warning: compilation may fail because you're using"
3067
            echo "/usr/ucb/cc, when you should use the C compiler from"
3068
            echo "$could_use.  You should change your"
3069
            echo "PATH or CC variable and rerun configure."
3070
        fi
3071
      fi
3072
  ;;
3073
esac
3074
 
3075
case "${host}" in
3076
  *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
3077
  *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
3078
  *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
3079
esac
3080
 
3081
# Record target_configdirs and the configure arguments for target and
3082
# build configuration in Makefile.
3083
target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
3084
build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
3085
 
3086
# Determine whether gdb needs tk/tcl or not.
3087
# Use 'maybe' since enable_gdbtk might be true even if tk isn't available
3088
# and in that case we want gdb to be built without tk.  Ugh!
3089
# In fact I believe gdb is the *only* package directly dependent on tk,
3090
# so we should be able to put the 'maybe's in unconditionally and
3091
# leave out the maybe dependencies when enable_gdbtk is false.  I'm not
3092
# 100% sure that that's safe though.
3093
 
3094
gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
3095
case "$enable_gdbtk" in
3096
  no)
3097
    GDB_TK="" ;;
3098
  yes)
3099
    GDB_TK="${gdb_tk}" ;;
3100
  *)
3101
    # Only add the dependency on gdbtk when GDBtk is part of the gdb
3102
    # distro.  Eventually someone will fix this and move Insight, nee
3103
    # gdbtk to a separate directory.
3104
    if test -d ${srcdir}/gdb/gdbtk ; then
3105
      GDB_TK="${gdb_tk}"
3106
    else
3107
      GDB_TK=""
3108
    fi
3109
    ;;
3110
esac
3111
CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
3112
INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
3113
 
3114
# Strip out unwanted targets.
3115
 
3116
# While at that, we remove Makefiles if we were started for recursive
3117
# configuration, so that the top-level Makefile reconfigures them,
3118
# like we used to do when configure itself was recursive.
3119
 
3120
# Loop over modules.  $extrasub must be used with care, limiting as
3121
# much as possible the usage of range addresses.  That's because autoconf
3122
# splits the sed script to overcome limits in the number of commands,
3123
# and relying on carefully-timed sed passes may turn out to be very hard
3124
# to maintain later.  In this particular case, you just have to be careful
3125
# not to nest @if/@endif pairs, because configure will not warn you at all.
3126
 
3127
# Check whether --enable-bootstrap or --disable-bootstrap was given.
3128
if test "${enable_bootstrap+set}" = set; then
3129
  enableval="$enable_bootstrap"
3130
  :
3131
else
3132
  enable_bootstrap=default
3133
fi
3134
 
3135
 
3136
# Issue errors and warnings for invalid/strange bootstrap combinations.
3137
case "$configdirs" in
3138
  *gcc*) have_compiler=yes ;;
3139
  *) have_compiler=no ;;
3140
esac
3141
 
3142
case "$have_compiler:$host:$target:$enable_bootstrap" in
3143
  *:*:*:no) ;;
3144
 
3145
  # Default behavior.  Enable bootstrap if we have a compiler
3146
  # and we are in a native configuration.
3147
  yes:$build:$build:default)
3148
    enable_bootstrap=yes ;;
3149
 
3150
  *:*:*:default)
3151
    enable_bootstrap=no ;;
3152
 
3153
  # We have a compiler and we are in a native configuration, bootstrap is ok
3154
  yes:$build:$build:yes)
3155
    ;;
3156
 
3157
  # Other configurations, but we have a compiler.  Assume the user knows
3158
  # what he's doing.
3159
  yes:*:*:yes)
3160
    echo "configure: warning: trying to bootstrap a cross compiler" 1>&2
3161
    ;;
3162
 
3163
  # No compiler: if they passed --enable-bootstrap explicitly, fail
3164
  no:*:*:yes)
3165
    { echo "configure: error: cannot bootstrap without a compiler" 1>&2; exit 1; } ;;
3166
 
3167
  # Fail if wrong command line
3168
  *)
3169
    { echo "configure: error: invalid option for --enable-bootstrap" 1>&2; exit 1; }
3170
    ;;
3171
esac
3172
 
3173
# Adjust the toplevel makefile according to whether bootstrap was selected.
3174
case "$enable_bootstrap" in
3175
  yes)
3176
    bootstrap_suffix=bootstrap ;;
3177
  no)
3178
    bootstrap_suffix=no-bootstrap ;;
3179
esac
3180
 
3181
for module in ${build_configdirs} ; do
3182
  if test -z "${no_recursion}" \
3183
     && test -f ${build_subdir}/${module}/Makefile; then
3184
    echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
3185
    rm -f ${build_subdir}/${module}/Makefile
3186
  fi
3187
  extrasub="$extrasub
3188
/^@if build-$module\$/d
3189
/^@endif build-$module\$/d
3190
/^@if build-$module-$bootstrap_suffix\$/d
3191
/^@endif build-$module-$bootstrap_suffix\$/d"
3192
done
3193
for module in ${configdirs} ; do
3194
  if test -z "${no_recursion}"; then
3195
    for file in stage*-${module}/Makefile ${module}/Makefile; do
3196
      if test -f ${file}; then
3197
        echo 1>&2 "*** removing ${file} to force reconfigure"
3198
        rm -f ${file}
3199
      fi
3200
    done
3201
  fi
3202
  extrasub="$extrasub
3203
/^@if $module\$/d
3204
/^@endif $module\$/d
3205
/^@if $module-$bootstrap_suffix\$/d
3206
/^@endif $module-$bootstrap_suffix\$/d"
3207
done
3208
for module in ${target_configdirs} ; do
3209
  if test -z "${no_recursion}" \
3210
     && test -f ${target_subdir}/${module}/Makefile; then
3211
    echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
3212
    rm -f ${target_subdir}/${module}/Makefile
3213
  fi
3214
  extrasub="$extrasub
3215
/^@if target-$module\$/d
3216
/^@endif target-$module\$/d
3217
/^@if target-$module-$bootstrap_suffix\$/d
3218
/^@endif target-$module-$bootstrap_suffix\$/d"
3219
done
3220
 
3221
extrasub="$extrasub
3222
/^@if /,/^@endif /d"
3223
 
3224
# Create the serialization dependencies.  This uses a temporary file.
3225
 
3226
# Check whether --enable-serial-configure or --disable-serial-configure was given.
3227
if test "${enable_serial_configure+set}" = set; then
3228
  enableval="$enable_serial_configure"
3229
  :
3230
fi
3231
 
3232
 
3233
case ${enable_serial_configure} in
3234
  yes)
3235
    enable_serial_build_configure=yes
3236
    enable_serial_host_configure=yes
3237
    enable_serial_target_configure=yes
3238
    ;;
3239
esac
3240
 
3241
# These force 'configure's to be done one at a time, to avoid problems
3242
# with contention over a shared config.cache.
3243
rm -f serdep.tmp
3244
echo '# serdep.tmp' > serdep.tmp
3245
olditem=
3246
test "x${enable_serial_build_configure}" = xyes &&
3247
for item in ${build_configdirs} ; do
3248
  case ${olditem} in
3249
    "") ;;
3250
    *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
3251
  esac
3252
  olditem=${item}
3253
done
3254
olditem=
3255
test "x${enable_serial_host_configure}" = xyes &&
3256
for item in ${configdirs} ; do
3257
  case ${olditem} in
3258
    "") ;;
3259
    *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
3260
  esac
3261
  olditem=${item}
3262
done
3263
olditem=
3264
test "x${enable_serial_target_configure}" = xyes &&
3265
for item in ${target_configdirs} ; do
3266
  case ${olditem} in
3267
    "") ;;
3268
    *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
3269
  esac
3270
  olditem=${item}
3271
done
3272
serialization_dependencies=serdep.tmp
3273
 
3274
 
3275
# Base args.  Strip norecursion, cache-file, srcdir, host, build,
3276
# target and nonopt.  These are the ones we might not want to pass
3277
# down to subconfigures.  Also strip program-prefix, program-suffix,
3278
# and program-transform-name, so that we can pass down a consistent
3279
# program-transform-name.  If autoconf has put single quotes around
3280
# any of these arguments (because they contain shell metacharacters)
3281
# then this will fail; in practice this only happens for
3282
# --program-transform-name, so be sure to override --program-transform-name
3283
# at the end of the argument list.
3284
# These will be expanded by make, so quote '$'.
3285
cat <<\EOF_SED > conftestsed
3286
s/ --no[^ ]*/ /g
3287
s/ --c[a-z-]*[= ][^ ]*//g
3288
s/ --sr[a-z-]*[= ][^ ]*//g
3289
s/ --ho[a-z-]*[= ][^ ]*//g
3290
s/ --bu[a-z-]*[= ][^ ]*//g
3291
s/ --t[a-z-]*[= ][^ ]*//g
3292
s/ --program-[pst][a-z-]*[= ][^ ]*//g
3293
s/ -cache-file[= ][^ ]*//g
3294
s/ -srcdir[= ][^ ]*//g
3295
s/ -host[= ][^ ]*//g
3296
s/ -build[= ][^ ]*//g
3297
s/ -target[= ][^ ]*//g
3298
s/ -program-prefix[= ][^ ]*//g
3299
s/ -program-suffix[= ][^ ]*//g
3300
s/ -program-transform-name[= ][^ ]*//g
3301
s/ [^' -][^ ]* / /
3302
s/^ *//;s/ *$//
3303
s,\$,$$,g
3304
EOF_SED
3305
sed -f conftestsed < conftestsed.out
3306
 ${ac_configure_args}
3307
EOF_SED
3308
baseargs=`cat conftestsed.out`
3309
rm -f conftestsed conftestsed.out
3310
 
3311
# Add in --program-transform-name, after --program-prefix and
3312
# --program-suffix have been applied to it.  Autoconf has already
3313
# doubled dollar signs and backslashes in program_transform_name; we want
3314
# the backslashes un-doubled, and then the entire thing wrapped in single
3315
# quotes, because this will be expanded first by make and then by the shell.
3316
# Also, because we want to override the logic in subdir configure scripts to
3317
# choose program_transform_name, replace any s,x,x, with s,y,y,.
3318
sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" < conftestsed.out
3319
${program_transform_name}
3320
EOF_SED
3321
gcc_transform_name=`cat conftestsed.out`
3322
rm -f conftestsed.out
3323
baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
3324
 
3325
# For the build-side libraries, we just need to pretend we're native,
3326
# and not use the same cache file.  Multilibs are neither needed nor
3327
# desired.
3328
build_configargs="--cache-file=../config.cache --build=${build_alias} --host=${build_alias} --target=${target_alias} ${baseargs}"
3329
 
3330
# For host modules, accept cache file option, or specification as blank.
3331
case "${cache_file}" in
3332
"") # empty
3333
  cache_file_option="" ;;
3334
/* | [A-Za-z]:[\\/]* ) # absolute path
3335
  cache_file_option="--cache-file=${cache_file}" ;;
3336
*) # relative path
3337
  cache_file_option="--cache-file=../${cache_file}" ;;
3338
esac
3339
 
3340
# Host dirs don't like to share a cache file either, horribly enough.
3341
# This seems to be due to autoconf 2.5x stupidity.
3342
host_configargs="--cache-file=./config.cache --build=${build_alias} --host=${host_alias} --target=${target_alias} ${extra_host_args} ${baseargs}"
3343
 
3344
target_configargs=${baseargs}
3345
 
3346
# Passing a --with-cross-host argument lets the target libraries know
3347
# whether they are being built with a cross-compiler or being built
3348
# native.  However, it would be better to use other mechanisms to make the
3349
# sorts of decisions they want to make on this basis.  Please consider
3350
# this option to be deprecated.  FIXME.
3351
if test x${is_cross_compiler} = xyes ; then
3352
  target_configargs="--with-cross-host=${host_alias} ${target_configargs}"
3353
fi
3354
 
3355
# Default to --enable-multilib.
3356
if test x${enable_multilib} = x ; then
3357
  target_configargs="--enable-multilib ${target_configargs}"
3358
fi
3359
 
3360
# Pass --with-newlib if appropriate.  Note that target_configdirs has
3361
# changed from the earlier setting of with_newlib.
3362
if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
3363
  target_configargs="--with-newlib ${target_configargs}"
3364
fi
3365
 
3366
# Different target subdirs use different values of certain variables
3367
# (notably CXX).  Worse, multilibs use *lots* of different values.
3368
# Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
3369
# it doesn't automatically accept command-line overrides of them.
3370
# This means it's not safe for target subdirs to share a cache file,
3371
# which is disgusting, but there you have it.  Hopefully this can be
3372
# fixed in future.  It's still worthwhile to use a cache file for each
3373
# directory.  I think.
3374
 
3375
# Pass the appropriate --build, --host, --target and --cache-file arguments.
3376
# We need to pass --target, as newer autoconf's requires consistency
3377
# for target_alias and gcc doesn't manage it consistently.
3378
target_configargs="--cache-file=./config.cache --build=${build_alias} --host=${target_alias} --target=${target_alias} ${target_configargs}"
3379
 
3380
FLAGS_FOR_TARGET=
3381
case " $target_configdirs " in
3382
 *" newlib "*)
3383
  case " $target_configargs " in
3384
  *" --with-newlib "*)
3385
   case "$target" in
3386
   *-cygwin*)
3387
     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' ;;
3388
   esac
3389
 
3390
   # If we're not building GCC, don't discard standard headers.
3391
   if test -d ${srcdir}/gcc; then
3392
     FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
3393
 
3394
     if test "${build}" != "${host}"; then
3395
       # On Canadian crosses, CC_FOR_TARGET will have already been set
3396
       # by `configure', so we won't have an opportunity to add -Bgcc/
3397
       # to it.  This is right: we don't want to search that directory
3398
       # for binaries, but we want the header files in there, so add
3399
       # them explicitly.
3400
       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
3401
 
3402
       # Someone might think of using the pre-installed headers on
3403
       # Canadian crosses, in case the installed compiler is not fully
3404
       # compatible with the compiler being built.  In this case, it
3405
       # would be better to flag an error than risking having
3406
       # incompatible object files being constructed.  We can't
3407
       # guarantee that an error will be flagged, but let's hope the
3408
       # compiler will do it, when presented with incompatible header
3409
       # files.
3410
     fi
3411
   fi
3412
 
3413
   case "${target}-${is_cross_compiler}" in
3414
   i[3456789]86-*-linux*-no)
3415
      # Here host == target, so we don't need to build gcc,
3416
      # so we don't want to discard standard headers.
3417
      FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
3418
      ;;
3419
   *)
3420
      # If we're building newlib, use its generic headers last, but search
3421
      # for any libc-related directories first (so make it the last -B
3422
      # switch).
3423
      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
3424
      ;;
3425
   esac
3426
   ;;
3427
  esac
3428
  ;;
3429
esac
3430
case "$target" in
3431
*-mingw*)
3432
  # Can't be handled as Cygwin above since Mingw does not use newlib.
3433
  FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/winsup/mingw -L$$r/$(TARGET_SUBDIR)/winsup/w32api/lib -isystem $$s/winsup/mingw/include -isystem $$s/winsup/w32api/include' ;;
3434
esac
3435
 
3436
# Allow the user to override the flags for
3437
# our build compiler if desired.
3438
CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
3439
 
3440
# On Canadian crosses, we'll be searching the right directories for
3441
# the previously-installed cross compiler, so don't bother to add
3442
# flags for directories within the install tree of the compiler
3443
# being built; programs in there won't even run.
3444
if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
3445
  # Search for pre-installed headers if nothing else fits.
3446
  FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
3447
fi
3448
 
3449
if test "x${use_gnu_ld}" = x &&
3450
   echo " ${configdirs} " | grep " ld " > /dev/null ; then
3451
  # Arrange for us to find uninstalled linker scripts.
3452
  FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
3453
fi
3454
 
3455
# Search for other target-specific linker scripts and such.
3456
case "${target}" in
3457
  m32c-*-* )
3458
    if test -d ${srcdir}/libgloss/m32c; then
3459
      # This is for crt0.o
3460
      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/m32c'
3461
      # This is for r8c.ld
3462
      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/m32c'
3463
      # This is for libnosys.a
3464
      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
3465
    fi
3466
    ;;
3467
esac
3468
 
3469
# Makefile fragments.
3470
for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
3471
do
3472
  eval fragval=\$$frag
3473
  if test $fragval != /dev/null; then
3474
    eval $frag=${srcdir}/$fragval
3475
  fi
3476
done
3477
 
3478
 
3479
 
3480
 
3481
 
3482
# Miscellanea: directories, flags, etc.
3483
 
3484
 
3485
 
3486
 
3487
 
3488
 
3489
 
3490
# Build module lists & subconfigure args.
3491
 
3492
 
3493
 
3494
# Host module lists & subconfigure args.
3495
 
3496
 
3497
 
3498
# Target module lists & subconfigure args.
3499
 
3500
 
3501
 
3502
# Build tools.
3503
 
3504
 
3505
 
3506
# Generate default definitions for YACC, M4, LEX and other programs that run
3507
# on the build machine.  These are used if the Makefile can't locate these
3508
# programs in objdir.
3509
MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
3510
 
3511
for ac_prog in 'bison -y' byacc yacc
3512
do
3513
# Extract the first word of "$ac_prog", so it can be a program name with args.
3514
set dummy $ac_prog; ac_word=$2
3515
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
3516
echo "configure:3513: checking for $ac_word" >&5
3517
if eval "test \"`echo '$''{'ac_cv_prog_YACC'+set}'`\" = set"; then
3518
  echo $ac_n "(cached) $ac_c" 1>&6
3519
else
3520
  if test -n "$YACC"; then
3521
  ac_cv_prog_YACC="$YACC" # Let the user override the test.
3522
else
3523
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3524
  ac_dummy="$PATH"
3525
  for ac_dir in $ac_dummy; do
3526
    test -z "$ac_dir" && ac_dir=.
3527
    if test -f $ac_dir/$ac_word; then
3528
      ac_cv_prog_YACC="$ac_prog"
3529
      break
3530
    fi
3531
  done
3532
  IFS="$ac_save_ifs"
3533
fi
3534
fi
3535
YACC="$ac_cv_prog_YACC"
3536
if test -n "$YACC"; then
3537
  echo "$ac_t""$YACC" 1>&6
3538
else
3539
  echo "$ac_t""no" 1>&6
3540
fi
3541
 
3542
test -n "$YACC" && break
3543
done
3544
test -n "$YACC" || YACC="$MISSING bison -y"
3545
 
3546
case " $build_configdirs " in
3547
  *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
3548
  *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
3549
esac
3550
 
3551
for ac_prog in bison
3552
do
3553
# Extract the first word of "$ac_prog", so it can be a program name with args.
3554
set dummy $ac_prog; ac_word=$2
3555
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
3556
echo "configure:3553: checking for $ac_word" >&5
3557
if eval "test \"`echo '$''{'ac_cv_prog_BISON'+set}'`\" = set"; then
3558
  echo $ac_n "(cached) $ac_c" 1>&6
3559
else
3560
  if test -n "$BISON"; then
3561
  ac_cv_prog_BISON="$BISON" # Let the user override the test.
3562
else
3563
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3564
  ac_dummy="$PATH"
3565
  for ac_dir in $ac_dummy; do
3566
    test -z "$ac_dir" && ac_dir=.
3567
    if test -f $ac_dir/$ac_word; then
3568
      ac_cv_prog_BISON="$ac_prog"
3569
      break
3570
    fi
3571
  done
3572
  IFS="$ac_save_ifs"
3573
fi
3574
fi
3575
BISON="$ac_cv_prog_BISON"
3576
if test -n "$BISON"; then
3577
  echo "$ac_t""$BISON" 1>&6
3578
else
3579
  echo "$ac_t""no" 1>&6
3580
fi
3581
 
3582
test -n "$BISON" && break
3583
done
3584
test -n "$BISON" || BISON="$MISSING bison"
3585
 
3586
case " $build_configdirs " in
3587
  *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
3588
esac
3589
 
3590
for ac_prog in gm4 gnum4 m4
3591
do
3592
# Extract the first word of "$ac_prog", so it can be a program name with args.
3593
set dummy $ac_prog; ac_word=$2
3594
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
3595
echo "configure:3592: checking for $ac_word" >&5
3596
if eval "test \"`echo '$''{'ac_cv_prog_M4'+set}'`\" = set"; then
3597
  echo $ac_n "(cached) $ac_c" 1>&6
3598
else
3599
  if test -n "$M4"; then
3600
  ac_cv_prog_M4="$M4" # Let the user override the test.
3601
else
3602
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3603
  ac_dummy="$PATH"
3604
  for ac_dir in $ac_dummy; do
3605
    test -z "$ac_dir" && ac_dir=.
3606
    if test -f $ac_dir/$ac_word; then
3607
      ac_cv_prog_M4="$ac_prog"
3608
      break
3609
    fi
3610
  done
3611
  IFS="$ac_save_ifs"
3612
fi
3613
fi
3614
M4="$ac_cv_prog_M4"
3615
if test -n "$M4"; then
3616
  echo "$ac_t""$M4" 1>&6
3617
else
3618
  echo "$ac_t""no" 1>&6
3619
fi
3620
 
3621
test -n "$M4" && break
3622
done
3623
test -n "$M4" || M4="$MISSING m4"
3624
 
3625
case " $build_configdirs " in
3626
  *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
3627
esac
3628
 
3629
for ac_prog in flex lex
3630
do
3631
# Extract the first word of "$ac_prog", so it can be a program name with args.
3632
set dummy $ac_prog; ac_word=$2
3633
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
3634
echo "configure:3631: checking for $ac_word" >&5
3635
if eval "test \"`echo '$''{'ac_cv_prog_LEX'+set}'`\" = set"; then
3636
  echo $ac_n "(cached) $ac_c" 1>&6
3637
else
3638
  if test -n "$LEX"; then
3639
  ac_cv_prog_LEX="$LEX" # Let the user override the test.
3640
else
3641
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3642
  ac_dummy="$PATH"
3643
  for ac_dir in $ac_dummy; do
3644
    test -z "$ac_dir" && ac_dir=.
3645
    if test -f $ac_dir/$ac_word; then
3646
      ac_cv_prog_LEX="$ac_prog"
3647
      break
3648
    fi
3649
  done
3650
  IFS="$ac_save_ifs"
3651
fi
3652
fi
3653
LEX="$ac_cv_prog_LEX"
3654
if test -n "$LEX"; then
3655
  echo "$ac_t""$LEX" 1>&6
3656
else
3657
  echo "$ac_t""no" 1>&6
3658
fi
3659
 
3660
test -n "$LEX" && break
3661
done
3662
test -n "$LEX" || LEX="$MISSING flex"
3663
 
3664
case " $build_configdirs " in
3665
  *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
3666
  *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
3667
esac
3668
 
3669
for ac_prog in flex
3670
do
3671
# Extract the first word of "$ac_prog", so it can be a program name with args.
3672
set dummy $ac_prog; ac_word=$2
3673
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
3674
echo "configure:3671: checking for $ac_word" >&5
3675
if eval "test \"`echo '$''{'ac_cv_prog_FLEX'+set}'`\" = set"; then
3676
  echo $ac_n "(cached) $ac_c" 1>&6
3677
else
3678
  if test -n "$FLEX"; then
3679
  ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
3680
else
3681
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3682
  ac_dummy="$PATH"
3683
  for ac_dir in $ac_dummy; do
3684
    test -z "$ac_dir" && ac_dir=.
3685
    if test -f $ac_dir/$ac_word; then
3686
      ac_cv_prog_FLEX="$ac_prog"
3687
      break
3688
    fi
3689
  done
3690
  IFS="$ac_save_ifs"
3691
fi
3692
fi
3693
FLEX="$ac_cv_prog_FLEX"
3694
if test -n "$FLEX"; then
3695
  echo "$ac_t""$FLEX" 1>&6
3696
else
3697
  echo "$ac_t""no" 1>&6
3698
fi
3699
 
3700
test -n "$FLEX" && break
3701
done
3702
test -n "$FLEX" || FLEX="$MISSING flex"
3703
 
3704
case " $build_configdirs " in
3705
  *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
3706
esac
3707
 
3708
for ac_prog in makeinfo
3709
do
3710
# Extract the first word of "$ac_prog", so it can be a program name with args.
3711
set dummy $ac_prog; ac_word=$2
3712
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
3713
echo "configure:3710: checking for $ac_word" >&5
3714
if eval "test \"`echo '$''{'ac_cv_prog_MAKEINFO'+set}'`\" = set"; then
3715
  echo $ac_n "(cached) $ac_c" 1>&6
3716
else
3717
  if test -n "$MAKEINFO"; then
3718
  ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
3719
else
3720
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3721
  ac_dummy="$PATH"
3722
  for ac_dir in $ac_dummy; do
3723
    test -z "$ac_dir" && ac_dir=.
3724
    if test -f $ac_dir/$ac_word; then
3725
      ac_cv_prog_MAKEINFO="$ac_prog"
3726
      break
3727
    fi
3728
  done
3729
  IFS="$ac_save_ifs"
3730
fi
3731
fi
3732
MAKEINFO="$ac_cv_prog_MAKEINFO"
3733
if test -n "$MAKEINFO"; then
3734
  echo "$ac_t""$MAKEINFO" 1>&6
3735
else
3736
  echo "$ac_t""no" 1>&6
3737
fi
3738
 
3739
test -n "$MAKEINFO" && break
3740
done
3741
test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
3742
 
3743
case " $build_configdirs " in
3744
  *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
3745
  *)
3746
 
3747
    # For an installed makeinfo, we require it to be from texinfo 4.4 or
3748
    # higher, else we use the "missing" dummy.
3749
    if ${MAKEINFO} --version \
3750
       | egrep 'texinfo[^0-9]*(4\.([4-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
3751
      :
3752
    else
3753
      MAKEINFO="$MISSING makeinfo"
3754
    fi
3755
    ;;
3756
 
3757
esac
3758
 
3759
# FIXME: expect and dejagnu may become build tools?
3760
 
3761
for ac_prog in expect
3762
do
3763
# Extract the first word of "$ac_prog", so it can be a program name with args.
3764
set dummy $ac_prog; ac_word=$2
3765
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
3766
echo "configure:3763: checking for $ac_word" >&5
3767
if eval "test \"`echo '$''{'ac_cv_prog_EXPECT'+set}'`\" = set"; then
3768
  echo $ac_n "(cached) $ac_c" 1>&6
3769
else
3770
  if test -n "$EXPECT"; then
3771
  ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
3772
else
3773
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3774
  ac_dummy="$PATH"
3775
  for ac_dir in $ac_dummy; do
3776
    test -z "$ac_dir" && ac_dir=.
3777
    if test -f $ac_dir/$ac_word; then
3778
      ac_cv_prog_EXPECT="$ac_prog"
3779
      break
3780
    fi
3781
  done
3782
  IFS="$ac_save_ifs"
3783
fi
3784
fi
3785
EXPECT="$ac_cv_prog_EXPECT"
3786
if test -n "$EXPECT"; then
3787
  echo "$ac_t""$EXPECT" 1>&6
3788
else
3789
  echo "$ac_t""no" 1>&6
3790
fi
3791
 
3792
test -n "$EXPECT" && break
3793
done
3794
test -n "$EXPECT" || EXPECT="expect"
3795
 
3796
case " $configdirs " in
3797
  *" expect "*)
3798
    test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
3799
    ;;
3800
esac
3801
 
3802
for ac_prog in runtest
3803
do
3804
# Extract the first word of "$ac_prog", so it can be a program name with args.
3805
set dummy $ac_prog; ac_word=$2
3806
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
3807
echo "configure:3804: checking for $ac_word" >&5
3808
if eval "test \"`echo '$''{'ac_cv_prog_RUNTEST'+set}'`\" = set"; then
3809
  echo $ac_n "(cached) $ac_c" 1>&6
3810
else
3811
  if test -n "$RUNTEST"; then
3812
  ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
3813
else
3814
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3815
  ac_dummy="$PATH"
3816
  for ac_dir in $ac_dummy; do
3817
    test -z "$ac_dir" && ac_dir=.
3818
    if test -f $ac_dir/$ac_word; then
3819
      ac_cv_prog_RUNTEST="$ac_prog"
3820
      break
3821
    fi
3822
  done
3823
  IFS="$ac_save_ifs"
3824
fi
3825
fi
3826
RUNTEST="$ac_cv_prog_RUNTEST"
3827
if test -n "$RUNTEST"; then
3828
  echo "$ac_t""$RUNTEST" 1>&6
3829
else
3830
  echo "$ac_t""no" 1>&6
3831
fi
3832
 
3833
test -n "$RUNTEST" && break
3834
done
3835
test -n "$RUNTEST" || RUNTEST="runtest"
3836
 
3837
case " $configdirs " in
3838
  *" dejagnu "*)
3839
    test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
3840
    ;;
3841
esac
3842
 
3843
 
3844
# Host tools.
3845
ncn_tool_prefix=
3846
test -n "$host_alias" && ncn_tool_prefix=$host_alias-
3847
ncn_target_tool_prefix=
3848
test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
3849
 
3850
 for ncn_progname in ar; do
3851
  if test -n "$ncn_tool_prefix"; then
3852
    # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
3853
set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
3854
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
3855
echo "configure:3852: checking for $ac_word" >&5
3856
if eval "test \"`echo '$''{'ac_cv_prog_AR'+set}'`\" = set"; then
3857
  echo $ac_n "(cached) $ac_c" 1>&6
3858
else
3859
  if test -n "$AR"; then
3860
  ac_cv_prog_AR="$AR" # Let the user override the test.
3861
else
3862
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3863
  ac_dummy="$PATH"
3864
  for ac_dir in $ac_dummy; do
3865
    test -z "$ac_dir" && ac_dir=.
3866
    if test -f $ac_dir/$ac_word; then
3867
      ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
3868
      break
3869
    fi
3870
  done
3871
  IFS="$ac_save_ifs"
3872
fi
3873
fi
3874
AR="$ac_cv_prog_AR"
3875
if test -n "$AR"; then
3876
  echo "$ac_t""$AR" 1>&6
3877
else
3878
  echo "$ac_t""no" 1>&6
3879
fi
3880
 
3881
  fi
3882
  if test -z "$ac_cv_prog_AR" && test $build = $host ; then
3883
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
3884
set dummy ${ncn_progname}; ac_word=$2
3885
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
3886
echo "configure:3883: checking for $ac_word" >&5
3887
if eval "test \"`echo '$''{'ac_cv_prog_AR'+set}'`\" = set"; then
3888
  echo $ac_n "(cached) $ac_c" 1>&6
3889
else
3890
  if test -n "$AR"; then
3891
  ac_cv_prog_AR="$AR" # Let the user override the test.
3892
else
3893
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3894
  ac_dummy="$PATH"
3895
  for ac_dir in $ac_dummy; do
3896
    test -z "$ac_dir" && ac_dir=.
3897
    if test -f $ac_dir/$ac_word; then
3898
      ac_cv_prog_AR="${ncn_progname}"
3899
      break
3900
    fi
3901
  done
3902
  IFS="$ac_save_ifs"
3903
fi
3904
fi
3905
AR="$ac_cv_prog_AR"
3906
if test -n "$AR"; then
3907
  echo "$ac_t""$AR" 1>&6
3908
else
3909
  echo "$ac_t""no" 1>&6
3910
fi
3911
 
3912
  fi
3913
  test -n "$ac_cv_prog_AR" && break
3914
done
3915
 
3916
if test -z "$ac_cv_prog_AR" ; then
3917
  set dummy ar
3918
  if test $build = $host ; then
3919
    AR="$2"
3920
  else
3921
    AR="${ncn_tool_prefix}$2"
3922
  fi
3923
fi
3924
 
3925
 for ncn_progname in as; do
3926
  if test -n "$ncn_tool_prefix"; then
3927
    # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
3928
set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
3929
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
3930
echo "configure:3927: checking for $ac_word" >&5
3931
if eval "test \"`echo '$''{'ac_cv_prog_AS'+set}'`\" = set"; then
3932
  echo $ac_n "(cached) $ac_c" 1>&6
3933
else
3934
  if test -n "$AS"; then
3935
  ac_cv_prog_AS="$AS" # Let the user override the test.
3936
else
3937
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3938
  ac_dummy="$PATH"
3939
  for ac_dir in $ac_dummy; do
3940
    test -z "$ac_dir" && ac_dir=.
3941
    if test -f $ac_dir/$ac_word; then
3942
      ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
3943
      break
3944
    fi
3945
  done
3946
  IFS="$ac_save_ifs"
3947
fi
3948
fi
3949
AS="$ac_cv_prog_AS"
3950
if test -n "$AS"; then
3951
  echo "$ac_t""$AS" 1>&6
3952
else
3953
  echo "$ac_t""no" 1>&6
3954
fi
3955
 
3956
  fi
3957
  if test -z "$ac_cv_prog_AS" && test $build = $host ; then
3958
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
3959
set dummy ${ncn_progname}; ac_word=$2
3960
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
3961
echo "configure:3958: checking for $ac_word" >&5
3962
if eval "test \"`echo '$''{'ac_cv_prog_AS'+set}'`\" = set"; then
3963
  echo $ac_n "(cached) $ac_c" 1>&6
3964
else
3965
  if test -n "$AS"; then
3966
  ac_cv_prog_AS="$AS" # Let the user override the test.
3967
else
3968
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3969
  ac_dummy="$PATH"
3970
  for ac_dir in $ac_dummy; do
3971
    test -z "$ac_dir" && ac_dir=.
3972
    if test -f $ac_dir/$ac_word; then
3973
      ac_cv_prog_AS="${ncn_progname}"
3974
      break
3975
    fi
3976
  done
3977
  IFS="$ac_save_ifs"
3978
fi
3979
fi
3980
AS="$ac_cv_prog_AS"
3981
if test -n "$AS"; then
3982
  echo "$ac_t""$AS" 1>&6
3983
else
3984
  echo "$ac_t""no" 1>&6
3985
fi
3986
 
3987
  fi
3988
  test -n "$ac_cv_prog_AS" && break
3989
done
3990
 
3991
if test -z "$ac_cv_prog_AS" ; then
3992
  set dummy as
3993
  if test $build = $host ; then
3994
    AS="$2"
3995
  else
3996
    AS="${ncn_tool_prefix}$2"
3997
  fi
3998
fi
3999
 
4000
 for ncn_progname in dlltool; do
4001
  if test -n "$ncn_tool_prefix"; then
4002
    # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
4003
set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
4004
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4005
echo "configure:4002: checking for $ac_word" >&5
4006
if eval "test \"`echo '$''{'ac_cv_prog_DLLTOOL'+set}'`\" = set"; then
4007
  echo $ac_n "(cached) $ac_c" 1>&6
4008
else
4009
  if test -n "$DLLTOOL"; then
4010
  ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
4011
else
4012
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4013
  ac_dummy="$PATH"
4014
  for ac_dir in $ac_dummy; do
4015
    test -z "$ac_dir" && ac_dir=.
4016
    if test -f $ac_dir/$ac_word; then
4017
      ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
4018
      break
4019
    fi
4020
  done
4021
  IFS="$ac_save_ifs"
4022
fi
4023
fi
4024
DLLTOOL="$ac_cv_prog_DLLTOOL"
4025
if test -n "$DLLTOOL"; then
4026
  echo "$ac_t""$DLLTOOL" 1>&6
4027
else
4028
  echo "$ac_t""no" 1>&6
4029
fi
4030
 
4031
  fi
4032
  if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
4033
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
4034
set dummy ${ncn_progname}; ac_word=$2
4035
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4036
echo "configure:4033: checking for $ac_word" >&5
4037
if eval "test \"`echo '$''{'ac_cv_prog_DLLTOOL'+set}'`\" = set"; then
4038
  echo $ac_n "(cached) $ac_c" 1>&6
4039
else
4040
  if test -n "$DLLTOOL"; then
4041
  ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
4042
else
4043
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4044
  ac_dummy="$PATH"
4045
  for ac_dir in $ac_dummy; do
4046
    test -z "$ac_dir" && ac_dir=.
4047
    if test -f $ac_dir/$ac_word; then
4048
      ac_cv_prog_DLLTOOL="${ncn_progname}"
4049
      break
4050
    fi
4051
  done
4052
  IFS="$ac_save_ifs"
4053
fi
4054
fi
4055
DLLTOOL="$ac_cv_prog_DLLTOOL"
4056
if test -n "$DLLTOOL"; then
4057
  echo "$ac_t""$DLLTOOL" 1>&6
4058
else
4059
  echo "$ac_t""no" 1>&6
4060
fi
4061
 
4062
  fi
4063
  test -n "$ac_cv_prog_DLLTOOL" && break
4064
done
4065
 
4066
if test -z "$ac_cv_prog_DLLTOOL" ; then
4067
  set dummy dlltool
4068
  if test $build = $host ; then
4069
    DLLTOOL="$2"
4070
  else
4071
    DLLTOOL="${ncn_tool_prefix}$2"
4072
  fi
4073
fi
4074
 
4075
 for ncn_progname in ld; do
4076
  if test -n "$ncn_tool_prefix"; then
4077
    # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
4078
set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
4079
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4080
echo "configure:4077: checking for $ac_word" >&5
4081
if eval "test \"`echo '$''{'ac_cv_prog_LD'+set}'`\" = set"; then
4082
  echo $ac_n "(cached) $ac_c" 1>&6
4083
else
4084
  if test -n "$LD"; then
4085
  ac_cv_prog_LD="$LD" # Let the user override the test.
4086
else
4087
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4088
  ac_dummy="$PATH"
4089
  for ac_dir in $ac_dummy; do
4090
    test -z "$ac_dir" && ac_dir=.
4091
    if test -f $ac_dir/$ac_word; then
4092
      ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
4093
      break
4094
    fi
4095
  done
4096
  IFS="$ac_save_ifs"
4097
fi
4098
fi
4099
LD="$ac_cv_prog_LD"
4100
if test -n "$LD"; then
4101
  echo "$ac_t""$LD" 1>&6
4102
else
4103
  echo "$ac_t""no" 1>&6
4104
fi
4105
 
4106
  fi
4107
  if test -z "$ac_cv_prog_LD" && test $build = $host ; then
4108
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
4109
set dummy ${ncn_progname}; ac_word=$2
4110
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4111
echo "configure:4108: checking for $ac_word" >&5
4112
if eval "test \"`echo '$''{'ac_cv_prog_LD'+set}'`\" = set"; then
4113
  echo $ac_n "(cached) $ac_c" 1>&6
4114
else
4115
  if test -n "$LD"; then
4116
  ac_cv_prog_LD="$LD" # Let the user override the test.
4117
else
4118
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4119
  ac_dummy="$PATH"
4120
  for ac_dir in $ac_dummy; do
4121
    test -z "$ac_dir" && ac_dir=.
4122
    if test -f $ac_dir/$ac_word; then
4123
      ac_cv_prog_LD="${ncn_progname}"
4124
      break
4125
    fi
4126
  done
4127
  IFS="$ac_save_ifs"
4128
fi
4129
fi
4130
LD="$ac_cv_prog_LD"
4131
if test -n "$LD"; then
4132
  echo "$ac_t""$LD" 1>&6
4133
else
4134
  echo "$ac_t""no" 1>&6
4135
fi
4136
 
4137
  fi
4138
  test -n "$ac_cv_prog_LD" && break
4139
done
4140
 
4141
if test -z "$ac_cv_prog_LD" ; then
4142
  set dummy ld
4143
  if test $build = $host ; then
4144
    LD="$2"
4145
  else
4146
    LD="${ncn_tool_prefix}$2"
4147
  fi
4148
fi
4149
 
4150
 for ncn_progname in lipo; do
4151
  if test -n "$ncn_tool_prefix"; then
4152
    # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
4153
set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
4154
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4155
echo "configure:4152: checking for $ac_word" >&5
4156
if eval "test \"`echo '$''{'ac_cv_prog_LIPO'+set}'`\" = set"; then
4157
  echo $ac_n "(cached) $ac_c" 1>&6
4158
else
4159
  if test -n "$LIPO"; then
4160
  ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
4161
else
4162
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4163
  ac_dummy="$PATH"
4164
  for ac_dir in $ac_dummy; do
4165
    test -z "$ac_dir" && ac_dir=.
4166
    if test -f $ac_dir/$ac_word; then
4167
      ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
4168
      break
4169
    fi
4170
  done
4171
  IFS="$ac_save_ifs"
4172
fi
4173
fi
4174
LIPO="$ac_cv_prog_LIPO"
4175
if test -n "$LIPO"; then
4176
  echo "$ac_t""$LIPO" 1>&6
4177
else
4178
  echo "$ac_t""no" 1>&6
4179
fi
4180
 
4181
  fi
4182
  if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
4183
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
4184
set dummy ${ncn_progname}; ac_word=$2
4185
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4186
echo "configure:4183: checking for $ac_word" >&5
4187
if eval "test \"`echo '$''{'ac_cv_prog_LIPO'+set}'`\" = set"; then
4188
  echo $ac_n "(cached) $ac_c" 1>&6
4189
else
4190
  if test -n "$LIPO"; then
4191
  ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
4192
else
4193
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4194
  ac_dummy="$PATH"
4195
  for ac_dir in $ac_dummy; do
4196
    test -z "$ac_dir" && ac_dir=.
4197
    if test -f $ac_dir/$ac_word; then
4198
      ac_cv_prog_LIPO="${ncn_progname}"
4199
      break
4200
    fi
4201
  done
4202
  IFS="$ac_save_ifs"
4203
fi
4204
fi
4205
LIPO="$ac_cv_prog_LIPO"
4206
if test -n "$LIPO"; then
4207
  echo "$ac_t""$LIPO" 1>&6
4208
else
4209
  echo "$ac_t""no" 1>&6
4210
fi
4211
 
4212
  fi
4213
  test -n "$ac_cv_prog_LIPO" && break
4214
done
4215
 
4216
if test -z "$ac_cv_prog_LIPO" ; then
4217
  set dummy lipo
4218
  if test $build = $host ; then
4219
    LIPO="$2"
4220
  else
4221
    LIPO="${ncn_tool_prefix}$2"
4222
  fi
4223
fi
4224
 
4225
 for ncn_progname in nm; do
4226
  if test -n "$ncn_tool_prefix"; then
4227
    # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
4228
set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
4229
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4230
echo "configure:4227: checking for $ac_word" >&5
4231
if eval "test \"`echo '$''{'ac_cv_prog_NM'+set}'`\" = set"; then
4232
  echo $ac_n "(cached) $ac_c" 1>&6
4233
else
4234
  if test -n "$NM"; then
4235
  ac_cv_prog_NM="$NM" # Let the user override the test.
4236
else
4237
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4238
  ac_dummy="$PATH"
4239
  for ac_dir in $ac_dummy; do
4240
    test -z "$ac_dir" && ac_dir=.
4241
    if test -f $ac_dir/$ac_word; then
4242
      ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
4243
      break
4244
    fi
4245
  done
4246
  IFS="$ac_save_ifs"
4247
fi
4248
fi
4249
NM="$ac_cv_prog_NM"
4250
if test -n "$NM"; then
4251
  echo "$ac_t""$NM" 1>&6
4252
else
4253
  echo "$ac_t""no" 1>&6
4254
fi
4255
 
4256
  fi
4257
  if test -z "$ac_cv_prog_NM" && test $build = $host ; then
4258
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
4259
set dummy ${ncn_progname}; ac_word=$2
4260
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4261
echo "configure:4258: checking for $ac_word" >&5
4262
if eval "test \"`echo '$''{'ac_cv_prog_NM'+set}'`\" = set"; then
4263
  echo $ac_n "(cached) $ac_c" 1>&6
4264
else
4265
  if test -n "$NM"; then
4266
  ac_cv_prog_NM="$NM" # Let the user override the test.
4267
else
4268
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4269
  ac_dummy="$PATH"
4270
  for ac_dir in $ac_dummy; do
4271
    test -z "$ac_dir" && ac_dir=.
4272
    if test -f $ac_dir/$ac_word; then
4273
      ac_cv_prog_NM="${ncn_progname}"
4274
      break
4275
    fi
4276
  done
4277
  IFS="$ac_save_ifs"
4278
fi
4279
fi
4280
NM="$ac_cv_prog_NM"
4281
if test -n "$NM"; then
4282
  echo "$ac_t""$NM" 1>&6
4283
else
4284
  echo "$ac_t""no" 1>&6
4285
fi
4286
 
4287
  fi
4288
  test -n "$ac_cv_prog_NM" && break
4289
done
4290
 
4291
if test -z "$ac_cv_prog_NM" ; then
4292
  set dummy nm
4293
  if test $build = $host ; then
4294
    NM="$2"
4295
  else
4296
    NM="${ncn_tool_prefix}$2"
4297
  fi
4298
fi
4299
 
4300
 for ncn_progname in ranlib; do
4301
  if test -n "$ncn_tool_prefix"; then
4302
    # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
4303
set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
4304
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4305
echo "configure:4302: checking for $ac_word" >&5
4306
if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
4307
  echo $ac_n "(cached) $ac_c" 1>&6
4308
else
4309
  if test -n "$RANLIB"; then
4310
  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
4311
else
4312
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4313
  ac_dummy="$PATH"
4314
  for ac_dir in $ac_dummy; do
4315
    test -z "$ac_dir" && ac_dir=.
4316
    if test -f $ac_dir/$ac_word; then
4317
      ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
4318
      break
4319
    fi
4320
  done
4321
  IFS="$ac_save_ifs"
4322
fi
4323
fi
4324
RANLIB="$ac_cv_prog_RANLIB"
4325
if test -n "$RANLIB"; then
4326
  echo "$ac_t""$RANLIB" 1>&6
4327
else
4328
  echo "$ac_t""no" 1>&6
4329
fi
4330
 
4331
  fi
4332
  if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
4333
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
4334
set dummy ${ncn_progname}; ac_word=$2
4335
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4336
echo "configure:4333: checking for $ac_word" >&5
4337
if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
4338
  echo $ac_n "(cached) $ac_c" 1>&6
4339
else
4340
  if test -n "$RANLIB"; then
4341
  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
4342
else
4343
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4344
  ac_dummy="$PATH"
4345
  for ac_dir in $ac_dummy; do
4346
    test -z "$ac_dir" && ac_dir=.
4347
    if test -f $ac_dir/$ac_word; then
4348
      ac_cv_prog_RANLIB="${ncn_progname}"
4349
      break
4350
    fi
4351
  done
4352
  IFS="$ac_save_ifs"
4353
fi
4354
fi
4355
RANLIB="$ac_cv_prog_RANLIB"
4356
if test -n "$RANLIB"; then
4357
  echo "$ac_t""$RANLIB" 1>&6
4358
else
4359
  echo "$ac_t""no" 1>&6
4360
fi
4361
 
4362
  fi
4363
  test -n "$ac_cv_prog_RANLIB" && break
4364
done
4365
 
4366
if test -z "$ac_cv_prog_RANLIB" ; then
4367
  RANLIB=":"
4368
fi
4369
 
4370
 for ncn_progname in strip; do
4371
  if test -n "$ncn_tool_prefix"; then
4372
    # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
4373
set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
4374
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4375
echo "configure:4372: checking for $ac_word" >&5
4376
if eval "test \"`echo '$''{'ac_cv_prog_STRIP'+set}'`\" = set"; then
4377
  echo $ac_n "(cached) $ac_c" 1>&6
4378
else
4379
  if test -n "$STRIP"; then
4380
  ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
4381
else
4382
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4383
  ac_dummy="$PATH"
4384
  for ac_dir in $ac_dummy; do
4385
    test -z "$ac_dir" && ac_dir=.
4386
    if test -f $ac_dir/$ac_word; then
4387
      ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
4388
      break
4389
    fi
4390
  done
4391
  IFS="$ac_save_ifs"
4392
fi
4393
fi
4394
STRIP="$ac_cv_prog_STRIP"
4395
if test -n "$STRIP"; then
4396
  echo "$ac_t""$STRIP" 1>&6
4397
else
4398
  echo "$ac_t""no" 1>&6
4399
fi
4400
 
4401
  fi
4402
  if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
4403
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
4404
set dummy ${ncn_progname}; ac_word=$2
4405
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4406
echo "configure:4403: checking for $ac_word" >&5
4407
if eval "test \"`echo '$''{'ac_cv_prog_STRIP'+set}'`\" = set"; then
4408
  echo $ac_n "(cached) $ac_c" 1>&6
4409
else
4410
  if test -n "$STRIP"; then
4411
  ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
4412
else
4413
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4414
  ac_dummy="$PATH"
4415
  for ac_dir in $ac_dummy; do
4416
    test -z "$ac_dir" && ac_dir=.
4417
    if test -f $ac_dir/$ac_word; then
4418
      ac_cv_prog_STRIP="${ncn_progname}"
4419
      break
4420
    fi
4421
  done
4422
  IFS="$ac_save_ifs"
4423
fi
4424
fi
4425
STRIP="$ac_cv_prog_STRIP"
4426
if test -n "$STRIP"; then
4427
  echo "$ac_t""$STRIP" 1>&6
4428
else
4429
  echo "$ac_t""no" 1>&6
4430
fi
4431
 
4432
  fi
4433
  test -n "$ac_cv_prog_STRIP" && break
4434
done
4435
 
4436
if test -z "$ac_cv_prog_STRIP" ; then
4437
  STRIP=":"
4438
fi
4439
 
4440
 for ncn_progname in windres; do
4441
  if test -n "$ncn_tool_prefix"; then
4442
    # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
4443
set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
4444
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4445
echo "configure:4442: checking for $ac_word" >&5
4446
if eval "test \"`echo '$''{'ac_cv_prog_WINDRES'+set}'`\" = set"; then
4447
  echo $ac_n "(cached) $ac_c" 1>&6
4448
else
4449
  if test -n "$WINDRES"; then
4450
  ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
4451
else
4452
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4453
  ac_dummy="$PATH"
4454
  for ac_dir in $ac_dummy; do
4455
    test -z "$ac_dir" && ac_dir=.
4456
    if test -f $ac_dir/$ac_word; then
4457
      ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
4458
      break
4459
    fi
4460
  done
4461
  IFS="$ac_save_ifs"
4462
fi
4463
fi
4464
WINDRES="$ac_cv_prog_WINDRES"
4465
if test -n "$WINDRES"; then
4466
  echo "$ac_t""$WINDRES" 1>&6
4467
else
4468
  echo "$ac_t""no" 1>&6
4469
fi
4470
 
4471
  fi
4472
  if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
4473
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
4474
set dummy ${ncn_progname}; ac_word=$2
4475
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4476
echo "configure:4473: checking for $ac_word" >&5
4477
if eval "test \"`echo '$''{'ac_cv_prog_WINDRES'+set}'`\" = set"; then
4478
  echo $ac_n "(cached) $ac_c" 1>&6
4479
else
4480
  if test -n "$WINDRES"; then
4481
  ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
4482
else
4483
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4484
  ac_dummy="$PATH"
4485
  for ac_dir in $ac_dummy; do
4486
    test -z "$ac_dir" && ac_dir=.
4487
    if test -f $ac_dir/$ac_word; then
4488
      ac_cv_prog_WINDRES="${ncn_progname}"
4489
      break
4490
    fi
4491
  done
4492
  IFS="$ac_save_ifs"
4493
fi
4494
fi
4495
WINDRES="$ac_cv_prog_WINDRES"
4496
if test -n "$WINDRES"; then
4497
  echo "$ac_t""$WINDRES" 1>&6
4498
else
4499
  echo "$ac_t""no" 1>&6
4500
fi
4501
 
4502
  fi
4503
  test -n "$ac_cv_prog_WINDRES" && break
4504
done
4505
 
4506
if test -z "$ac_cv_prog_WINDRES" ; then
4507
  set dummy windres
4508
  if test $build = $host ; then
4509
    WINDRES="$2"
4510
  else
4511
    WINDRES="${ncn_tool_prefix}$2"
4512
  fi
4513
fi
4514
 
4515
 for ncn_progname in objcopy; do
4516
  if test -n "$ncn_tool_prefix"; then
4517
    # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
4518
set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
4519
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4520
echo "configure:4517: checking for $ac_word" >&5
4521
if eval "test \"`echo '$''{'ac_cv_prog_OBJCOPY'+set}'`\" = set"; then
4522
  echo $ac_n "(cached) $ac_c" 1>&6
4523
else
4524
  if test -n "$OBJCOPY"; then
4525
  ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
4526
else
4527
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4528
  ac_dummy="$PATH"
4529
  for ac_dir in $ac_dummy; do
4530
    test -z "$ac_dir" && ac_dir=.
4531
    if test -f $ac_dir/$ac_word; then
4532
      ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
4533
      break
4534
    fi
4535
  done
4536
  IFS="$ac_save_ifs"
4537
fi
4538
fi
4539
OBJCOPY="$ac_cv_prog_OBJCOPY"
4540
if test -n "$OBJCOPY"; then
4541
  echo "$ac_t""$OBJCOPY" 1>&6
4542
else
4543
  echo "$ac_t""no" 1>&6
4544
fi
4545
 
4546
  fi
4547
  if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
4548
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
4549
set dummy ${ncn_progname}; ac_word=$2
4550
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4551
echo "configure:4548: checking for $ac_word" >&5
4552
if eval "test \"`echo '$''{'ac_cv_prog_OBJCOPY'+set}'`\" = set"; then
4553
  echo $ac_n "(cached) $ac_c" 1>&6
4554
else
4555
  if test -n "$OBJCOPY"; then
4556
  ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
4557
else
4558
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4559
  ac_dummy="$PATH"
4560
  for ac_dir in $ac_dummy; do
4561
    test -z "$ac_dir" && ac_dir=.
4562
    if test -f $ac_dir/$ac_word; then
4563
      ac_cv_prog_OBJCOPY="${ncn_progname}"
4564
      break
4565
    fi
4566
  done
4567
  IFS="$ac_save_ifs"
4568
fi
4569
fi
4570
OBJCOPY="$ac_cv_prog_OBJCOPY"
4571
if test -n "$OBJCOPY"; then
4572
  echo "$ac_t""$OBJCOPY" 1>&6
4573
else
4574
  echo "$ac_t""no" 1>&6
4575
fi
4576
 
4577
  fi
4578
  test -n "$ac_cv_prog_OBJCOPY" && break
4579
done
4580
 
4581
if test -z "$ac_cv_prog_OBJCOPY" ; then
4582
  set dummy objcopy
4583
  if test $build = $host ; then
4584
    OBJCOPY="$2"
4585
  else
4586
    OBJCOPY="${ncn_tool_prefix}$2"
4587
  fi
4588
fi
4589
 
4590
 for ncn_progname in objdump; do
4591
  if test -n "$ncn_tool_prefix"; then
4592
    # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
4593
set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
4594
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4595
echo "configure:4592: checking for $ac_word" >&5
4596
if eval "test \"`echo '$''{'ac_cv_prog_OBJDUMP'+set}'`\" = set"; then
4597
  echo $ac_n "(cached) $ac_c" 1>&6
4598
else
4599
  if test -n "$OBJDUMP"; then
4600
  ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
4601
else
4602
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4603
  ac_dummy="$PATH"
4604
  for ac_dir in $ac_dummy; do
4605
    test -z "$ac_dir" && ac_dir=.
4606
    if test -f $ac_dir/$ac_word; then
4607
      ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
4608
      break
4609
    fi
4610
  done
4611
  IFS="$ac_save_ifs"
4612
fi
4613
fi
4614
OBJDUMP="$ac_cv_prog_OBJDUMP"
4615
if test -n "$OBJDUMP"; then
4616
  echo "$ac_t""$OBJDUMP" 1>&6
4617
else
4618
  echo "$ac_t""no" 1>&6
4619
fi
4620
 
4621
  fi
4622
  if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
4623
    # Extract the first word of "${ncn_progname}", so it can be a program name with args.
4624
set dummy ${ncn_progname}; ac_word=$2
4625
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4626
echo "configure:4623: checking for $ac_word" >&5
4627
if eval "test \"`echo '$''{'ac_cv_prog_OBJDUMP'+set}'`\" = set"; then
4628
  echo $ac_n "(cached) $ac_c" 1>&6
4629
else
4630
  if test -n "$OBJDUMP"; then
4631
  ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
4632
else
4633
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4634
  ac_dummy="$PATH"
4635
  for ac_dir in $ac_dummy; do
4636
    test -z "$ac_dir" && ac_dir=.
4637
    if test -f $ac_dir/$ac_word; then
4638
      ac_cv_prog_OBJDUMP="${ncn_progname}"
4639
      break
4640
    fi
4641
  done
4642
  IFS="$ac_save_ifs"
4643
fi
4644
fi
4645
OBJDUMP="$ac_cv_prog_OBJDUMP"
4646
if test -n "$OBJDUMP"; then
4647
  echo "$ac_t""$OBJDUMP" 1>&6
4648
else
4649
  echo "$ac_t""no" 1>&6
4650
fi
4651
 
4652
  fi
4653
  test -n "$ac_cv_prog_OBJDUMP" && break
4654
done
4655
 
4656
if test -z "$ac_cv_prog_OBJDUMP" ; then
4657
  set dummy objdump
4658
  if test $build = $host ; then
4659
    OBJDUMP="$2"
4660
  else
4661
    OBJDUMP="${ncn_tool_prefix}$2"
4662
  fi
4663
fi
4664
 
4665
 
4666
 
4667
 
4668
 
4669
 
4670
 
4671
# Target tools.
4672
# Check whether --with-build-time-tools or --without-build-time-tools was given.
4673
if test "${with_build_time_tools+set}" = set; then
4674
  withval="$with_build_time_tools"
4675
  case x"$withval" in
4676
     x/*) ;;
4677
     *)
4678
       with_build_time_tools=
4679
       echo "configure: warning: argument to --with-build-time-tools must be an absolute path" 1>&2
4680
       ;;
4681
   esac
4682
else
4683
  with_build_time_tools=
4684
fi
4685
 
4686
 
4687
 if test -n "$with_build_time_tools"; then
4688
  for ncn_progname in cc gcc; do
4689
    echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
4690
echo "configure:4687: checking for ${ncn_progname} in $with_build_time_tools" >&5
4691
    if test -x $with_build_time_tools/${ncn_progname}; then
4692
      ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
4693
      echo "$ac_t""yes" 1>&6
4694
      break
4695
    else
4696
      echo "$ac_t""no" 1>&6
4697
    fi
4698
  done
4699
fi
4700
 
4701
if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
4702
  for ncn_progname in cc gcc; do
4703
    if test -n "$ncn_target_tool_prefix"; then
4704
      # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
4705
set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
4706
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4707
echo "configure:4704: checking for $ac_word" >&5
4708
if eval "test \"`echo '$''{'ac_cv_prog_CC_FOR_TARGET'+set}'`\" = set"; then
4709
  echo $ac_n "(cached) $ac_c" 1>&6
4710
else
4711
  if test -n "$CC_FOR_TARGET"; then
4712
  ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
4713
else
4714
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4715
  ac_dummy="$PATH"
4716
  for ac_dir in $ac_dummy; do
4717
    test -z "$ac_dir" && ac_dir=.
4718
    if test -f $ac_dir/$ac_word; then
4719
      ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
4720
      break
4721
    fi
4722
  done
4723
  IFS="$ac_save_ifs"
4724
fi
4725
fi
4726
CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
4727
if test -n "$CC_FOR_TARGET"; then
4728
  echo "$ac_t""$CC_FOR_TARGET" 1>&6
4729
else
4730
  echo "$ac_t""no" 1>&6
4731
fi
4732
 
4733
    fi
4734
    if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
4735
      # Extract the first word of "${ncn_progname}", so it can be a program name with args.
4736
set dummy ${ncn_progname}; ac_word=$2
4737
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4738
echo "configure:4735: checking for $ac_word" >&5
4739
if eval "test \"`echo '$''{'ac_cv_prog_CC_FOR_TARGET'+set}'`\" = set"; then
4740
  echo $ac_n "(cached) $ac_c" 1>&6
4741
else
4742
  if test -n "$CC_FOR_TARGET"; then
4743
  ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
4744
else
4745
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4746
  ac_dummy="$PATH"
4747
  for ac_dir in $ac_dummy; do
4748
    test -z "$ac_dir" && ac_dir=.
4749
    if test -f $ac_dir/$ac_word; then
4750
      ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
4751
      break
4752
    fi
4753
  done
4754
  IFS="$ac_save_ifs"
4755
fi
4756
fi
4757
CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
4758
if test -n "$CC_FOR_TARGET"; then
4759
  echo "$ac_t""$CC_FOR_TARGET" 1>&6
4760
else
4761
  echo "$ac_t""no" 1>&6
4762
fi
4763
 
4764
    fi
4765
    test -n "$ac_cv_prog_CC_FOR_TARGET" && break
4766
  done
4767
fi
4768
 
4769
if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
4770
  set dummy cc gcc
4771
  if test $build = $target ; then
4772
    CC_FOR_TARGET="$2"
4773
  else
4774
    CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
4775
  fi
4776
else
4777
  CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
4778
fi
4779
 
4780
 if test -n "$with_build_time_tools"; then
4781
  for ncn_progname in c++ g++ cxx gxx; do
4782
    echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
4783
echo "configure:4780: checking for ${ncn_progname} in $with_build_time_tools" >&5
4784
    if test -x $with_build_time_tools/${ncn_progname}; then
4785
      ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
4786
      echo "$ac_t""yes" 1>&6
4787
      break
4788
    else
4789
      echo "$ac_t""no" 1>&6
4790
    fi
4791
  done
4792
fi
4793
 
4794
if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
4795
  for ncn_progname in c++ g++ cxx gxx; do
4796
    if test -n "$ncn_target_tool_prefix"; then
4797
      # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
4798
set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
4799
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4800
echo "configure:4797: checking for $ac_word" >&5
4801
if eval "test \"`echo '$''{'ac_cv_prog_CXX_FOR_TARGET'+set}'`\" = set"; then
4802
  echo $ac_n "(cached) $ac_c" 1>&6
4803
else
4804
  if test -n "$CXX_FOR_TARGET"; then
4805
  ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
4806
else
4807
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4808
  ac_dummy="$PATH"
4809
  for ac_dir in $ac_dummy; do
4810
    test -z "$ac_dir" && ac_dir=.
4811
    if test -f $ac_dir/$ac_word; then
4812
      ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
4813
      break
4814
    fi
4815
  done
4816
  IFS="$ac_save_ifs"
4817
fi
4818
fi
4819
CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
4820
if test -n "$CXX_FOR_TARGET"; then
4821
  echo "$ac_t""$CXX_FOR_TARGET" 1>&6
4822
else
4823
  echo "$ac_t""no" 1>&6
4824
fi
4825
 
4826
    fi
4827
    if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
4828
      # Extract the first word of "${ncn_progname}", so it can be a program name with args.
4829
set dummy ${ncn_progname}; ac_word=$2
4830
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4831
echo "configure:4828: checking for $ac_word" >&5
4832
if eval "test \"`echo '$''{'ac_cv_prog_CXX_FOR_TARGET'+set}'`\" = set"; then
4833
  echo $ac_n "(cached) $ac_c" 1>&6
4834
else
4835
  if test -n "$CXX_FOR_TARGET"; then
4836
  ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
4837
else
4838
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4839
  ac_dummy="$PATH"
4840
  for ac_dir in $ac_dummy; do
4841
    test -z "$ac_dir" && ac_dir=.
4842
    if test -f $ac_dir/$ac_word; then
4843
      ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
4844
      break
4845
    fi
4846
  done
4847
  IFS="$ac_save_ifs"
4848
fi
4849
fi
4850
CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
4851
if test -n "$CXX_FOR_TARGET"; then
4852
  echo "$ac_t""$CXX_FOR_TARGET" 1>&6
4853
else
4854
  echo "$ac_t""no" 1>&6
4855
fi
4856
 
4857
    fi
4858
    test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
4859
  done
4860
fi
4861
 
4862
if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
4863
  set dummy c++ g++ cxx gxx
4864
  if test $build = $target ; then
4865
    CXX_FOR_TARGET="$2"
4866
  else
4867
    CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
4868
  fi
4869
else
4870
  CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
4871
fi
4872
 
4873
 if test -n "$with_build_time_tools"; then
4874
  for ncn_progname in gcc; do
4875
    echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
4876
echo "configure:4873: checking for ${ncn_progname} in $with_build_time_tools" >&5
4877
    if test -x $with_build_time_tools/${ncn_progname}; then
4878
      ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
4879
      echo "$ac_t""yes" 1>&6
4880
      break
4881
    else
4882
      echo "$ac_t""no" 1>&6
4883
    fi
4884
  done
4885
fi
4886
 
4887
if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
4888
  for ncn_progname in gcc; do
4889
    if test -n "$ncn_target_tool_prefix"; then
4890
      # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
4891
set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
4892
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4893
echo "configure:4890: checking for $ac_word" >&5
4894
if eval "test \"`echo '$''{'ac_cv_prog_GCC_FOR_TARGET'+set}'`\" = set"; then
4895
  echo $ac_n "(cached) $ac_c" 1>&6
4896
else
4897
  if test -n "$GCC_FOR_TARGET"; then
4898
  ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
4899
else
4900
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4901
  ac_dummy="$PATH"
4902
  for ac_dir in $ac_dummy; do
4903
    test -z "$ac_dir" && ac_dir=.
4904
    if test -f $ac_dir/$ac_word; then
4905
      ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
4906
      break
4907
    fi
4908
  done
4909
  IFS="$ac_save_ifs"
4910
fi
4911
fi
4912
GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
4913
if test -n "$GCC_FOR_TARGET"; then
4914
  echo "$ac_t""$GCC_FOR_TARGET" 1>&6
4915
else
4916
  echo "$ac_t""no" 1>&6
4917
fi
4918
 
4919
    fi
4920
    if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
4921
      # Extract the first word of "${ncn_progname}", so it can be a program name with args.
4922
set dummy ${ncn_progname}; ac_word=$2
4923
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4924
echo "configure:4921: checking for $ac_word" >&5
4925
if eval "test \"`echo '$''{'ac_cv_prog_GCC_FOR_TARGET'+set}'`\" = set"; then
4926
  echo $ac_n "(cached) $ac_c" 1>&6
4927
else
4928
  if test -n "$GCC_FOR_TARGET"; then
4929
  ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
4930
else
4931
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4932
  ac_dummy="$PATH"
4933
  for ac_dir in $ac_dummy; do
4934
    test -z "$ac_dir" && ac_dir=.
4935
    if test -f $ac_dir/$ac_word; then
4936
      ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
4937
      break
4938
    fi
4939
  done
4940
  IFS="$ac_save_ifs"
4941
fi
4942
fi
4943
GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
4944
if test -n "$GCC_FOR_TARGET"; then
4945
  echo "$ac_t""$GCC_FOR_TARGET" 1>&6
4946
else
4947
  echo "$ac_t""no" 1>&6
4948
fi
4949
 
4950
    fi
4951
    test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
4952
  done
4953
fi
4954
 
4955
if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
4956
  GCC_FOR_TARGET="${CC_FOR_TARGET}"
4957
else
4958
  GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
4959
fi
4960
 
4961
 if test -n "$with_build_time_tools"; then
4962
  for ncn_progname in gcj; do
4963
    echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
4964
echo "configure:4961: checking for ${ncn_progname} in $with_build_time_tools" >&5
4965
    if test -x $with_build_time_tools/${ncn_progname}; then
4966
      ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
4967
      echo "$ac_t""yes" 1>&6
4968
      break
4969
    else
4970
      echo "$ac_t""no" 1>&6
4971
    fi
4972
  done
4973
fi
4974
 
4975
if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
4976
  for ncn_progname in gcj; do
4977
    if test -n "$ncn_target_tool_prefix"; then
4978
      # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
4979
set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
4980
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4981
echo "configure:4978: checking for $ac_word" >&5
4982
if eval "test \"`echo '$''{'ac_cv_prog_GCJ_FOR_TARGET'+set}'`\" = set"; then
4983
  echo $ac_n "(cached) $ac_c" 1>&6
4984
else
4985
  if test -n "$GCJ_FOR_TARGET"; then
4986
  ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
4987
else
4988
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4989
  ac_dummy="$PATH"
4990
  for ac_dir in $ac_dummy; do
4991
    test -z "$ac_dir" && ac_dir=.
4992
    if test -f $ac_dir/$ac_word; then
4993
      ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
4994
      break
4995
    fi
4996
  done
4997
  IFS="$ac_save_ifs"
4998
fi
4999
fi
5000
GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
5001
if test -n "$GCJ_FOR_TARGET"; then
5002
  echo "$ac_t""$GCJ_FOR_TARGET" 1>&6
5003
else
5004
  echo "$ac_t""no" 1>&6
5005
fi
5006
 
5007
    fi
5008
    if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
5009
      # Extract the first word of "${ncn_progname}", so it can be a program name with args.
5010
set dummy ${ncn_progname}; ac_word=$2
5011
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5012
echo "configure:5009: checking for $ac_word" >&5
5013
if eval "test \"`echo '$''{'ac_cv_prog_GCJ_FOR_TARGET'+set}'`\" = set"; then
5014
  echo $ac_n "(cached) $ac_c" 1>&6
5015
else
5016
  if test -n "$GCJ_FOR_TARGET"; then
5017
  ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
5018
else
5019
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5020
  ac_dummy="$PATH"
5021
  for ac_dir in $ac_dummy; do
5022
    test -z "$ac_dir" && ac_dir=.
5023
    if test -f $ac_dir/$ac_word; then
5024
      ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
5025
      break
5026
    fi
5027
  done
5028
  IFS="$ac_save_ifs"
5029
fi
5030
fi
5031
GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
5032
if test -n "$GCJ_FOR_TARGET"; then
5033
  echo "$ac_t""$GCJ_FOR_TARGET" 1>&6
5034
else
5035
  echo "$ac_t""no" 1>&6
5036
fi
5037
 
5038
    fi
5039
    test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
5040
  done
5041
fi
5042
 
5043
if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
5044
  set dummy gcj
5045
  if test $build = $target ; then
5046
    GCJ_FOR_TARGET="$2"
5047
  else
5048
    GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
5049
  fi
5050
else
5051
  GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
5052
fi
5053
 
5054
 if test -n "$with_build_time_tools"; then
5055
  for ncn_progname in gfortran; do
5056
    echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
5057
echo "configure:5054: checking for ${ncn_progname} in $with_build_time_tools" >&5
5058
    if test -x $with_build_time_tools/${ncn_progname}; then
5059
      ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
5060
      echo "$ac_t""yes" 1>&6
5061
      break
5062
    else
5063
      echo "$ac_t""no" 1>&6
5064
    fi
5065
  done
5066
fi
5067
 
5068
if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
5069
  for ncn_progname in gfortran; do
5070
    if test -n "$ncn_target_tool_prefix"; then
5071
      # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
5072
set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
5073
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5074
echo "configure:5071: checking for $ac_word" >&5
5075
if eval "test \"`echo '$''{'ac_cv_prog_GFORTRAN_FOR_TARGET'+set}'`\" = set"; then
5076
  echo $ac_n "(cached) $ac_c" 1>&6
5077
else
5078
  if test -n "$GFORTRAN_FOR_TARGET"; then
5079
  ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
5080
else
5081
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5082
  ac_dummy="$PATH"
5083
  for ac_dir in $ac_dummy; do
5084
    test -z "$ac_dir" && ac_dir=.
5085
    if test -f $ac_dir/$ac_word; then
5086
      ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
5087
      break
5088
    fi
5089
  done
5090
  IFS="$ac_save_ifs"
5091
fi
5092
fi
5093
GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
5094
if test -n "$GFORTRAN_FOR_TARGET"; then
5095
  echo "$ac_t""$GFORTRAN_FOR_TARGET" 1>&6
5096
else
5097
  echo "$ac_t""no" 1>&6
5098
fi
5099
 
5100
    fi
5101
    if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
5102
      # Extract the first word of "${ncn_progname}", so it can be a program name with args.
5103
set dummy ${ncn_progname}; ac_word=$2
5104
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5105
echo "configure:5102: checking for $ac_word" >&5
5106
if eval "test \"`echo '$''{'ac_cv_prog_GFORTRAN_FOR_TARGET'+set}'`\" = set"; then
5107
  echo $ac_n "(cached) $ac_c" 1>&6
5108
else
5109
  if test -n "$GFORTRAN_FOR_TARGET"; then
5110
  ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
5111
else
5112
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5113
  ac_dummy="$PATH"
5114
  for ac_dir in $ac_dummy; do
5115
    test -z "$ac_dir" && ac_dir=.
5116
    if test -f $ac_dir/$ac_word; then
5117
      ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
5118
      break
5119
    fi
5120
  done
5121
  IFS="$ac_save_ifs"
5122
fi
5123
fi
5124
GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
5125
if test -n "$GFORTRAN_FOR_TARGET"; then
5126
  echo "$ac_t""$GFORTRAN_FOR_TARGET" 1>&6
5127
else
5128
  echo "$ac_t""no" 1>&6
5129
fi
5130
 
5131
    fi
5132
    test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
5133
  done
5134
fi
5135
 
5136
if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
5137
  set dummy gfortran
5138
  if test $build = $target ; then
5139
    GFORTRAN_FOR_TARGET="$2"
5140
  else
5141
    GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
5142
  fi
5143
else
5144
  GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
5145
fi
5146
 
5147
 
5148
 
5149
# The user is always right.
5150
if test "${PATH_SEPARATOR+set}" != set; then
5151
  echo "#! /bin/sh" >conf$$.sh
5152
  echo  "exit 0"   >>conf$$.sh
5153
  chmod +x conf$$.sh
5154
  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5155
    PATH_SEPARATOR=';'
5156
  else
5157
    PATH_SEPARATOR=:
5158
  fi
5159
  rm -f conf$$.sh
5160
fi
5161
 
5162
 
5163
 
5164
if test "x$exec_prefix" = xNONE; then
5165
        if test "x$prefix" = xNONE; then
5166
                gcc_cv_tool_prefix=$ac_default_prefix
5167
        else
5168
                gcc_cv_tool_prefix=$prefix
5169
        fi
5170
else
5171
        gcc_cv_tool_prefix=$exec_prefix
5172
fi
5173
 
5174
# If there is no compiler in the tree, use the PATH only.  In any
5175
# case, if there is no compiler in the tree nobody should use
5176
# AS_FOR_TARGET and LD_FOR_TARGET.
5177
if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5178
    gcc_version=`cat $srcdir/gcc/BASE-VER`
5179
    gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5180
    gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5181
    gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5182
    gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5183
    gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5184
    gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5185
else
5186
    gcc_cv_tool_dirs=
5187
fi
5188
 
5189
if test x$build = x$target && test -n "$md_exec_prefix"; then
5190
        gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5191
fi
5192
 
5193
 
5194
 
5195
cat > conftest.c << \EOF
5196
#ifdef __GNUC__
5197
  gcc_yay;
5198
#endif
5199
EOF
5200
if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
5201
  have_gcc_for_target=yes
5202
else
5203
  GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
5204
  have_gcc_for_target=no
5205
fi
5206
rm conftest.c
5207
 
5208
 
5209
 
5210
 
5211
if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
5212
  if test -n "$with_build_time_tools"; then
5213
    echo $ac_n "checking for ar in $with_build_time_tools""... $ac_c" 1>&6
5214
echo "configure:5211: checking for ar in $with_build_time_tools" >&5
5215
    if test -x $with_build_time_tools/ar; then
5216
      AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
5217
      ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
5218
      echo "$ac_t""$ac_cv_path_AR_FOR_TARGET" 1>&6
5219
    else
5220
      echo "$ac_t""no" 1>&6
5221
    fi
5222
  elif test $build != $host && test $have_gcc_for_target = yes; then
5223
    AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
5224
    test $AR_FOR_TARGET=ar && AR_FOR_TARGET=
5225
    test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
5226
  fi
5227
fi
5228
if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
5229
  # Extract the first word of "ar", so it can be a program name with args.
5230
set dummy ar; ac_word=$2
5231
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5232
echo "configure:5229: checking for $ac_word" >&5
5233
if eval "test \"`echo '$''{'ac_cv_path_AR_FOR_TARGET'+set}'`\" = set"; then
5234
  echo $ac_n "(cached) $ac_c" 1>&6
5235
else
5236
  case "$AR_FOR_TARGET" in
5237
  /*)
5238
  ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
5239
  ;;
5240
  ?:/*)
5241
  ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a dos path.
5242
  ;;
5243
  *)
5244
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5245
  ac_dummy="$gcc_cv_tool_dirs"
5246
  for ac_dir in $ac_dummy; do
5247
    test -z "$ac_dir" && ac_dir=.
5248
    if test -f $ac_dir/$ac_word; then
5249
      ac_cv_path_AR_FOR_TARGET="$ac_dir/$ac_word"
5250
      break
5251
    fi
5252
  done
5253
  IFS="$ac_save_ifs"
5254
  ;;
5255
esac
5256
fi
5257
AR_FOR_TARGET="$ac_cv_path_AR_FOR_TARGET"
5258
if test -n "$AR_FOR_TARGET"; then
5259
  echo "$ac_t""$AR_FOR_TARGET" 1>&6
5260
else
5261
  echo "$ac_t""no" 1>&6
5262
fi
5263
 
5264
fi
5265
if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
5266
   if test -n "$with_build_time_tools"; then
5267
  for ncn_progname in ar; do
5268
    echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
5269
echo "configure:5266: checking for ${ncn_progname} in $with_build_time_tools" >&5
5270
    if test -x $with_build_time_tools/${ncn_progname}; then
5271
      ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
5272
      echo "$ac_t""yes" 1>&6
5273
      break
5274
    else
5275
      echo "$ac_t""no" 1>&6
5276
    fi
5277
  done
5278
fi
5279
 
5280
if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
5281
  for ncn_progname in ar; do
5282
    if test -n "$ncn_target_tool_prefix"; then
5283
      # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
5284
set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
5285
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5286
echo "configure:5283: checking for $ac_word" >&5
5287
if eval "test \"`echo '$''{'ac_cv_prog_AR_FOR_TARGET'+set}'`\" = set"; then
5288
  echo $ac_n "(cached) $ac_c" 1>&6
5289
else
5290
  if test -n "$AR_FOR_TARGET"; then
5291
  ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
5292
else
5293
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5294
  ac_dummy="$PATH"
5295
  for ac_dir in $ac_dummy; do
5296
    test -z "$ac_dir" && ac_dir=.
5297
    if test -f $ac_dir/$ac_word; then
5298
      ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
5299
      break
5300
    fi
5301
  done
5302
  IFS="$ac_save_ifs"
5303
fi
5304
fi
5305
AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
5306
if test -n "$AR_FOR_TARGET"; then
5307
  echo "$ac_t""$AR_FOR_TARGET" 1>&6
5308
else
5309
  echo "$ac_t""no" 1>&6
5310
fi
5311
 
5312
    fi
5313
    if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
5314
      # Extract the first word of "${ncn_progname}", so it can be a program name with args.
5315
set dummy ${ncn_progname}; ac_word=$2
5316
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5317
echo "configure:5314: checking for $ac_word" >&5
5318
if eval "test \"`echo '$''{'ac_cv_prog_AR_FOR_TARGET'+set}'`\" = set"; then
5319
  echo $ac_n "(cached) $ac_c" 1>&6
5320
else
5321
  if test -n "$AR_FOR_TARGET"; then
5322
  ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
5323
else
5324
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5325
  ac_dummy="$PATH"
5326
  for ac_dir in $ac_dummy; do
5327
    test -z "$ac_dir" && ac_dir=.
5328
    if test -f $ac_dir/$ac_word; then
5329
      ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
5330
      break
5331
    fi
5332
  done
5333
  IFS="$ac_save_ifs"
5334
fi
5335
fi
5336
AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
5337
if test -n "$AR_FOR_TARGET"; then
5338
  echo "$ac_t""$AR_FOR_TARGET" 1>&6
5339
else
5340
  echo "$ac_t""no" 1>&6
5341
fi
5342
 
5343
    fi
5344
    test -n "$ac_cv_prog_AR_FOR_TARGET" && break
5345
  done
5346
fi
5347
 
5348
if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
5349
  set dummy ar
5350
  if test $build = $target ; then
5351
    AR_FOR_TARGET="$2"
5352
  else
5353
    AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
5354
  fi
5355
else
5356
  AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
5357
fi
5358
 
5359
else
5360
  AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
5361
fi
5362
 
5363
 
5364
 
5365
 
5366
if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
5367
  if test -n "$with_build_time_tools"; then
5368
    echo $ac_n "checking for as in $with_build_time_tools""... $ac_c" 1>&6
5369
echo "configure:5366: checking for as in $with_build_time_tools" >&5
5370
    if test -x $with_build_time_tools/as; then
5371
      AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
5372
      ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
5373
      echo "$ac_t""$ac_cv_path_AS_FOR_TARGET" 1>&6
5374
    else
5375
      echo "$ac_t""no" 1>&6
5376
    fi
5377
  elif test $build != $host && test $have_gcc_for_target = yes; then
5378
    AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
5379
    test $AS_FOR_TARGET=as && AS_FOR_TARGET=
5380
    test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
5381
  fi
5382
fi
5383
if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
5384
  # Extract the first word of "as", so it can be a program name with args.
5385
set dummy as; ac_word=$2
5386
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5387
echo "configure:5384: checking for $ac_word" >&5
5388
if eval "test \"`echo '$''{'ac_cv_path_AS_FOR_TARGET'+set}'`\" = set"; then
5389
  echo $ac_n "(cached) $ac_c" 1>&6
5390
else
5391
  case "$AS_FOR_TARGET" in
5392
  /*)
5393
  ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
5394
  ;;
5395
  ?:/*)
5396
  ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a dos path.
5397
  ;;
5398
  *)
5399
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5400
  ac_dummy="$gcc_cv_tool_dirs"
5401
  for ac_dir in $ac_dummy; do
5402
    test -z "$ac_dir" && ac_dir=.
5403
    if test -f $ac_dir/$ac_word; then
5404
      ac_cv_path_AS_FOR_TARGET="$ac_dir/$ac_word"
5405
      break
5406
    fi
5407
  done
5408
  IFS="$ac_save_ifs"
5409
  ;;
5410
esac
5411
fi
5412
AS_FOR_TARGET="$ac_cv_path_AS_FOR_TARGET"
5413
if test -n "$AS_FOR_TARGET"; then
5414
  echo "$ac_t""$AS_FOR_TARGET" 1>&6
5415
else
5416
  echo "$ac_t""no" 1>&6
5417
fi
5418
 
5419
fi
5420
if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
5421
   if test -n "$with_build_time_tools"; then
5422
  for ncn_progname in as; do
5423
    echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
5424
echo "configure:5421: checking for ${ncn_progname} in $with_build_time_tools" >&5
5425
    if test -x $with_build_time_tools/${ncn_progname}; then
5426
      ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
5427
      echo "$ac_t""yes" 1>&6
5428
      break
5429
    else
5430
      echo "$ac_t""no" 1>&6
5431
    fi
5432
  done
5433
fi
5434
 
5435
if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
5436
  for ncn_progname in as; do
5437
    if test -n "$ncn_target_tool_prefix"; then
5438
      # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
5439
set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
5440
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5441
echo "configure:5438: checking for $ac_word" >&5
5442
if eval "test \"`echo '$''{'ac_cv_prog_AS_FOR_TARGET'+set}'`\" = set"; then
5443
  echo $ac_n "(cached) $ac_c" 1>&6
5444
else
5445
  if test -n "$AS_FOR_TARGET"; then
5446
  ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
5447
else
5448
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5449
  ac_dummy="$PATH"
5450
  for ac_dir in $ac_dummy; do
5451
    test -z "$ac_dir" && ac_dir=.
5452
    if test -f $ac_dir/$ac_word; then
5453
      ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
5454
      break
5455
    fi
5456
  done
5457
  IFS="$ac_save_ifs"
5458
fi
5459
fi
5460
AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
5461
if test -n "$AS_FOR_TARGET"; then
5462
  echo "$ac_t""$AS_FOR_TARGET" 1>&6
5463
else
5464
  echo "$ac_t""no" 1>&6
5465
fi
5466
 
5467
    fi
5468
    if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
5469
      # Extract the first word of "${ncn_progname}", so it can be a program name with args.
5470
set dummy ${ncn_progname}; ac_word=$2
5471
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5472
echo "configure:5469: checking for $ac_word" >&5
5473
if eval "test \"`echo '$''{'ac_cv_prog_AS_FOR_TARGET'+set}'`\" = set"; then
5474
  echo $ac_n "(cached) $ac_c" 1>&6
5475
else
5476
  if test -n "$AS_FOR_TARGET"; then
5477
  ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
5478
else
5479
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5480
  ac_dummy="$PATH"
5481
  for ac_dir in $ac_dummy; do
5482
    test -z "$ac_dir" && ac_dir=.
5483
    if test -f $ac_dir/$ac_word; then
5484
      ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
5485
      break
5486
    fi
5487
  done
5488
  IFS="$ac_save_ifs"
5489
fi
5490
fi
5491
AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
5492
if test -n "$AS_FOR_TARGET"; then
5493
  echo "$ac_t""$AS_FOR_TARGET" 1>&6
5494
else
5495
  echo "$ac_t""no" 1>&6
5496
fi
5497
 
5498
    fi
5499
    test -n "$ac_cv_prog_AS_FOR_TARGET" && break
5500
  done
5501
fi
5502
 
5503
if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
5504
  set dummy as
5505
  if test $build = $target ; then
5506
    AS_FOR_TARGET="$2"
5507
  else
5508
    AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
5509
  fi
5510
else
5511
  AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
5512
fi
5513
 
5514
else
5515
  AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
5516
fi
5517
 
5518
 
5519
 
5520
 
5521
if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
5522
  if test -n "$with_build_time_tools"; then
5523
    echo $ac_n "checking for dlltool in $with_build_time_tools""... $ac_c" 1>&6
5524
echo "configure:5521: checking for dlltool in $with_build_time_tools" >&5
5525
    if test -x $with_build_time_tools/dlltool; then
5526
      DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
5527
      ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
5528
      echo "$ac_t""$ac_cv_path_DLLTOOL_FOR_TARGET" 1>&6
5529
    else
5530
      echo "$ac_t""no" 1>&6
5531
    fi
5532
  elif test $build != $host && test $have_gcc_for_target = yes; then
5533
    DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
5534
    test $DLLTOOL_FOR_TARGET=dlltool && DLLTOOL_FOR_TARGET=
5535
    test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
5536
  fi
5537
fi
5538
if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
5539
  # Extract the first word of "dlltool", so it can be a program name with args.
5540
set dummy dlltool; ac_word=$2
5541
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5542
echo "configure:5539: checking for $ac_word" >&5
5543
if eval "test \"`echo '$''{'ac_cv_path_DLLTOOL_FOR_TARGET'+set}'`\" = set"; then
5544
  echo $ac_n "(cached) $ac_c" 1>&6
5545
else
5546
  case "$DLLTOOL_FOR_TARGET" in
5547
  /*)
5548
  ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
5549
  ;;
5550
  ?:/*)
5551
  ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a dos path.
5552
  ;;
5553
  *)
5554
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5555
  ac_dummy="$gcc_cv_tool_dirs"
5556
  for ac_dir in $ac_dummy; do
5557
    test -z "$ac_dir" && ac_dir=.
5558
    if test -f $ac_dir/$ac_word; then
5559
      ac_cv_path_DLLTOOL_FOR_TARGET="$ac_dir/$ac_word"
5560
      break
5561
    fi
5562
  done
5563
  IFS="$ac_save_ifs"
5564
  ;;
5565
esac
5566
fi
5567
DLLTOOL_FOR_TARGET="$ac_cv_path_DLLTOOL_FOR_TARGET"
5568
if test -n "$DLLTOOL_FOR_TARGET"; then
5569
  echo "$ac_t""$DLLTOOL_FOR_TARGET" 1>&6
5570
else
5571
  echo "$ac_t""no" 1>&6
5572
fi
5573
 
5574
fi
5575
if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
5576
   if test -n "$with_build_time_tools"; then
5577
  for ncn_progname in dlltool; do
5578
    echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
5579
echo "configure:5576: checking for ${ncn_progname} in $with_build_time_tools" >&5
5580
    if test -x $with_build_time_tools/${ncn_progname}; then
5581
      ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
5582
      echo "$ac_t""yes" 1>&6
5583
      break
5584
    else
5585
      echo "$ac_t""no" 1>&6
5586
    fi
5587
  done
5588
fi
5589
 
5590
if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
5591
  for ncn_progname in dlltool; do
5592
    if test -n "$ncn_target_tool_prefix"; then
5593
      # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
5594
set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
5595
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5596
echo "configure:5593: checking for $ac_word" >&5
5597
if eval "test \"`echo '$''{'ac_cv_prog_DLLTOOL_FOR_TARGET'+set}'`\" = set"; then
5598
  echo $ac_n "(cached) $ac_c" 1>&6
5599
else
5600
  if test -n "$DLLTOOL_FOR_TARGET"; then
5601
  ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
5602
else
5603
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5604
  ac_dummy="$PATH"
5605
  for ac_dir in $ac_dummy; do
5606
    test -z "$ac_dir" && ac_dir=.
5607
    if test -f $ac_dir/$ac_word; then
5608
      ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
5609
      break
5610
    fi
5611
  done
5612
  IFS="$ac_save_ifs"
5613
fi
5614
fi
5615
DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
5616
if test -n "$DLLTOOL_FOR_TARGET"; then
5617
  echo "$ac_t""$DLLTOOL_FOR_TARGET" 1>&6
5618
else
5619
  echo "$ac_t""no" 1>&6
5620
fi
5621
 
5622
    fi
5623
    if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
5624
      # Extract the first word of "${ncn_progname}", so it can be a program name with args.
5625
set dummy ${ncn_progname}; ac_word=$2
5626
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5627
echo "configure:5624: checking for $ac_word" >&5
5628
if eval "test \"`echo '$''{'ac_cv_prog_DLLTOOL_FOR_TARGET'+set}'`\" = set"; then
5629
  echo $ac_n "(cached) $ac_c" 1>&6
5630
else
5631
  if test -n "$DLLTOOL_FOR_TARGET"; then
5632
  ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
5633
else
5634
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5635
  ac_dummy="$PATH"
5636
  for ac_dir in $ac_dummy; do
5637
    test -z "$ac_dir" && ac_dir=.
5638
    if test -f $ac_dir/$ac_word; then
5639
      ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
5640
      break
5641
    fi
5642
  done
5643
  IFS="$ac_save_ifs"
5644
fi
5645
fi
5646
DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
5647
if test -n "$DLLTOOL_FOR_TARGET"; then
5648
  echo "$ac_t""$DLLTOOL_FOR_TARGET" 1>&6
5649
else
5650
  echo "$ac_t""no" 1>&6
5651
fi
5652
 
5653
    fi
5654
    test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
5655
  done
5656
fi
5657
 
5658
if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
5659
  set dummy dlltool
5660
  if test $build = $target ; then
5661
    DLLTOOL_FOR_TARGET="$2"
5662
  else
5663
    DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
5664
  fi
5665
else
5666
  DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
5667
fi
5668
 
5669
else
5670
  DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
5671
fi
5672
 
5673
 
5674
 
5675
 
5676
if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
5677
  if test -n "$with_build_time_tools"; then
5678
    echo $ac_n "checking for ld in $with_build_time_tools""... $ac_c" 1>&6
5679
echo "configure:5676: checking for ld in $with_build_time_tools" >&5
5680
    if test -x $with_build_time_tools/ld; then
5681
      LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
5682
      ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
5683
      echo "$ac_t""$ac_cv_path_LD_FOR_TARGET" 1>&6
5684
    else
5685
      echo "$ac_t""no" 1>&6
5686
    fi
5687
  elif test $build != $host && test $have_gcc_for_target = yes; then
5688
    LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
5689
    test $LD_FOR_TARGET=ld && LD_FOR_TARGET=
5690
    test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
5691
  fi
5692
fi
5693
if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
5694
  # Extract the first word of "ld", so it can be a program name with args.
5695
set dummy ld; ac_word=$2
5696
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5697
echo "configure:5694: checking for $ac_word" >&5
5698
if eval "test \"`echo '$''{'ac_cv_path_LD_FOR_TARGET'+set}'`\" = set"; then
5699
  echo $ac_n "(cached) $ac_c" 1>&6
5700
else
5701
  case "$LD_FOR_TARGET" in
5702
  /*)
5703
  ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
5704
  ;;
5705
  ?:/*)
5706
  ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a dos path.
5707
  ;;
5708
  *)
5709
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5710
  ac_dummy="$gcc_cv_tool_dirs"
5711
  for ac_dir in $ac_dummy; do
5712
    test -z "$ac_dir" && ac_dir=.
5713
    if test -f $ac_dir/$ac_word; then
5714
      ac_cv_path_LD_FOR_TARGET="$ac_dir/$ac_word"
5715
      break
5716
    fi
5717
  done
5718
  IFS="$ac_save_ifs"
5719
  ;;
5720
esac
5721
fi
5722
LD_FOR_TARGET="$ac_cv_path_LD_FOR_TARGET"
5723
if test -n "$LD_FOR_TARGET"; then
5724
  echo "$ac_t""$LD_FOR_TARGET" 1>&6
5725
else
5726
  echo "$ac_t""no" 1>&6
5727
fi
5728
 
5729
fi
5730
if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
5731
   if test -n "$with_build_time_tools"; then
5732
  for ncn_progname in ld; do
5733
    echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
5734
echo "configure:5731: checking for ${ncn_progname} in $with_build_time_tools" >&5
5735
    if test -x $with_build_time_tools/${ncn_progname}; then
5736
      ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
5737
      echo "$ac_t""yes" 1>&6
5738
      break
5739
    else
5740
      echo "$ac_t""no" 1>&6
5741
    fi
5742
  done
5743
fi
5744
 
5745
if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
5746
  for ncn_progname in ld; do
5747
    if test -n "$ncn_target_tool_prefix"; then
5748
      # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
5749
set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
5750
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5751
echo "configure:5748: checking for $ac_word" >&5
5752
if eval "test \"`echo '$''{'ac_cv_prog_LD_FOR_TARGET'+set}'`\" = set"; then
5753
  echo $ac_n "(cached) $ac_c" 1>&6
5754
else
5755
  if test -n "$LD_FOR_TARGET"; then
5756
  ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
5757
else
5758
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5759
  ac_dummy="$PATH"
5760
  for ac_dir in $ac_dummy; do
5761
    test -z "$ac_dir" && ac_dir=.
5762
    if test -f $ac_dir/$ac_word; then
5763
      ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
5764
      break
5765
    fi
5766
  done
5767
  IFS="$ac_save_ifs"
5768
fi
5769
fi
5770
LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
5771
if test -n "$LD_FOR_TARGET"; then
5772
  echo "$ac_t""$LD_FOR_TARGET" 1>&6
5773
else
5774
  echo "$ac_t""no" 1>&6
5775
fi
5776
 
5777
    fi
5778
    if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
5779
      # Extract the first word of "${ncn_progname}", so it can be a program name with args.
5780
set dummy ${ncn_progname}; ac_word=$2
5781
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5782
echo "configure:5779: checking for $ac_word" >&5
5783
if eval "test \"`echo '$''{'ac_cv_prog_LD_FOR_TARGET'+set}'`\" = set"; then
5784
  echo $ac_n "(cached) $ac_c" 1>&6
5785
else
5786
  if test -n "$LD_FOR_TARGET"; then
5787
  ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
5788
else
5789
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5790
  ac_dummy="$PATH"
5791
  for ac_dir in $ac_dummy; do
5792
    test -z "$ac_dir" && ac_dir=.
5793
    if test -f $ac_dir/$ac_word; then
5794
      ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
5795
      break
5796
    fi
5797
  done
5798
  IFS="$ac_save_ifs"
5799
fi
5800
fi
5801
LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
5802
if test -n "$LD_FOR_TARGET"; then
5803
  echo "$ac_t""$LD_FOR_TARGET" 1>&6
5804
else
5805
  echo "$ac_t""no" 1>&6
5806
fi
5807
 
5808
    fi
5809
    test -n "$ac_cv_prog_LD_FOR_TARGET" && break
5810
  done
5811
fi
5812
 
5813
if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
5814
  set dummy ld
5815
  if test $build = $target ; then
5816
    LD_FOR_TARGET="$2"
5817
  else
5818
    LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
5819
  fi
5820
else
5821
  LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
5822
fi
5823
 
5824
else
5825
  LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
5826
fi
5827
 
5828
 
5829
 
5830
 
5831
if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
5832
  if test -n "$with_build_time_tools"; then
5833
    echo $ac_n "checking for lipo in $with_build_time_tools""... $ac_c" 1>&6
5834
echo "configure:5831: checking for lipo in $with_build_time_tools" >&5
5835
    if test -x $with_build_time_tools/lipo; then
5836
      LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
5837
      ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
5838
      echo "$ac_t""$ac_cv_path_LIPO_FOR_TARGET" 1>&6
5839
    else
5840
      echo "$ac_t""no" 1>&6
5841
    fi
5842
  elif test $build != $host && test $have_gcc_for_target = yes; then
5843
    LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
5844
    test $LIPO_FOR_TARGET=lipo && LIPO_FOR_TARGET=
5845
    test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
5846
  fi
5847
fi
5848
if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
5849
  # Extract the first word of "lipo", so it can be a program name with args.
5850
set dummy lipo; ac_word=$2
5851
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5852
echo "configure:5849: checking for $ac_word" >&5
5853
if eval "test \"`echo '$''{'ac_cv_path_LIPO_FOR_TARGET'+set}'`\" = set"; then
5854
  echo $ac_n "(cached) $ac_c" 1>&6
5855
else
5856
  case "$LIPO_FOR_TARGET" in
5857
  /*)
5858
  ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
5859
  ;;
5860
  ?:/*)
5861
  ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a dos path.
5862
  ;;
5863
  *)
5864
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5865
  ac_dummy="$gcc_cv_tool_dirs"
5866
  for ac_dir in $ac_dummy; do
5867
    test -z "$ac_dir" && ac_dir=.
5868
    if test -f $ac_dir/$ac_word; then
5869
      ac_cv_path_LIPO_FOR_TARGET="$ac_dir/$ac_word"
5870
      break
5871
    fi
5872
  done
5873
  IFS="$ac_save_ifs"
5874
  ;;
5875
esac
5876
fi
5877
LIPO_FOR_TARGET="$ac_cv_path_LIPO_FOR_TARGET"
5878
if test -n "$LIPO_FOR_TARGET"; then
5879
  echo "$ac_t""$LIPO_FOR_TARGET" 1>&6
5880
else
5881
  echo "$ac_t""no" 1>&6
5882
fi
5883
 
5884
fi
5885
if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
5886
   if test -n "$with_build_time_tools"; then
5887
  for ncn_progname in lipo; do
5888
    echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
5889
echo "configure:5886: checking for ${ncn_progname} in $with_build_time_tools" >&5
5890
    if test -x $with_build_time_tools/${ncn_progname}; then
5891
      ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
5892
      echo "$ac_t""yes" 1>&6
5893
      break
5894
    else
5895
      echo "$ac_t""no" 1>&6
5896
    fi
5897
  done
5898
fi
5899
 
5900
if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
5901
  for ncn_progname in lipo; do
5902
    if test -n "$ncn_target_tool_prefix"; then
5903
      # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
5904
set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
5905
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5906
echo "configure:5903: checking for $ac_word" >&5
5907
if eval "test \"`echo '$''{'ac_cv_prog_LIPO_FOR_TARGET'+set}'`\" = set"; then
5908
  echo $ac_n "(cached) $ac_c" 1>&6
5909
else
5910
  if test -n "$LIPO_FOR_TARGET"; then
5911
  ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
5912
else
5913
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5914
  ac_dummy="$PATH"
5915
  for ac_dir in $ac_dummy; do
5916
    test -z "$ac_dir" && ac_dir=.
5917
    if test -f $ac_dir/$ac_word; then
5918
      ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
5919
      break
5920
    fi
5921
  done
5922
  IFS="$ac_save_ifs"
5923
fi
5924
fi
5925
LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
5926
if test -n "$LIPO_FOR_TARGET"; then
5927
  echo "$ac_t""$LIPO_FOR_TARGET" 1>&6
5928
else
5929
  echo "$ac_t""no" 1>&6
5930
fi
5931
 
5932
    fi
5933
    if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
5934
      # Extract the first word of "${ncn_progname}", so it can be a program name with args.
5935
set dummy ${ncn_progname}; ac_word=$2
5936
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5937
echo "configure:5934: checking for $ac_word" >&5
5938
if eval "test \"`echo '$''{'ac_cv_prog_LIPO_FOR_TARGET'+set}'`\" = set"; then
5939
  echo $ac_n "(cached) $ac_c" 1>&6
5940
else
5941
  if test -n "$LIPO_FOR_TARGET"; then
5942
  ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
5943
else
5944
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5945
  ac_dummy="$PATH"
5946
  for ac_dir in $ac_dummy; do
5947
    test -z "$ac_dir" && ac_dir=.
5948
    if test -f $ac_dir/$ac_word; then
5949
      ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
5950
      break
5951
    fi
5952
  done
5953
  IFS="$ac_save_ifs"
5954
fi
5955
fi
5956
LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
5957
if test -n "$LIPO_FOR_TARGET"; then
5958
  echo "$ac_t""$LIPO_FOR_TARGET" 1>&6
5959
else
5960
  echo "$ac_t""no" 1>&6
5961
fi
5962
 
5963
    fi
5964
    test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
5965
  done
5966
fi
5967
 
5968
if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
5969
  set dummy lipo
5970
  if test $build = $target ; then
5971
    LIPO_FOR_TARGET="$2"
5972
  else
5973
    LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
5974
  fi
5975
else
5976
  LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
5977
fi
5978
 
5979
else
5980
  LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
5981
fi
5982
 
5983
 
5984
 
5985
 
5986
if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
5987
  if test -n "$with_build_time_tools"; then
5988
    echo $ac_n "checking for nm in $with_build_time_tools""... $ac_c" 1>&6
5989
echo "configure:5986: checking for nm in $with_build_time_tools" >&5
5990
    if test -x $with_build_time_tools/nm; then
5991
      NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
5992
      ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
5993
      echo "$ac_t""$ac_cv_path_NM_FOR_TARGET" 1>&6
5994
    else
5995
      echo "$ac_t""no" 1>&6
5996
    fi
5997
  elif test $build != $host && test $have_gcc_for_target = yes; then
5998
    NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
5999
    test $NM_FOR_TARGET=nm && NM_FOR_TARGET=
6000
    test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
6001
  fi
6002
fi
6003
if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
6004
  # Extract the first word of "nm", so it can be a program name with args.
6005
set dummy nm; ac_word=$2
6006
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
6007
echo "configure:6004: checking for $ac_word" >&5
6008
if eval "test \"`echo '$''{'ac_cv_path_NM_FOR_TARGET'+set}'`\" = set"; then
6009
  echo $ac_n "(cached) $ac_c" 1>&6
6010
else
6011
  case "$NM_FOR_TARGET" in
6012
  /*)
6013
  ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
6014
  ;;
6015
  ?:/*)
6016
  ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a dos path.
6017
  ;;
6018
  *)
6019
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
6020
  ac_dummy="$gcc_cv_tool_dirs"
6021
  for ac_dir in $ac_dummy; do
6022
    test -z "$ac_dir" && ac_dir=.
6023
    if test -f $ac_dir/$ac_word; then
6024
      ac_cv_path_NM_FOR_TARGET="$ac_dir/$ac_word"
6025
      break
6026
    fi
6027
  done
6028
  IFS="$ac_save_ifs"
6029
  ;;
6030
esac
6031
fi
6032
NM_FOR_TARGET="$ac_cv_path_NM_FOR_TARGET"
6033
if test -n "$NM_FOR_TARGET"; then
6034
  echo "$ac_t""$NM_FOR_TARGET" 1>&6
6035
else
6036
  echo "$ac_t""no" 1>&6
6037
fi
6038
 
6039
fi
6040
if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
6041
   if test -n "$with_build_time_tools"; then
6042
  for ncn_progname in nm; do
6043
    echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
6044
echo "configure:6041: checking for ${ncn_progname} in $with_build_time_tools" >&5
6045
    if test -x $with_build_time_tools/${ncn_progname}; then
6046
      ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
6047
      echo "$ac_t""yes" 1>&6
6048
      break
6049
    else
6050
      echo "$ac_t""no" 1>&6
6051
    fi
6052
  done
6053
fi
6054
 
6055
if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
6056
  for ncn_progname in nm; do
6057
    if test -n "$ncn_target_tool_prefix"; then
6058
      # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
6059
set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
6060
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
6061
echo "configure:6058: checking for $ac_word" >&5
6062
if eval "test \"`echo '$''{'ac_cv_prog_NM_FOR_TARGET'+set}'`\" = set"; then
6063
  echo $ac_n "(cached) $ac_c" 1>&6
6064
else
6065
  if test -n "$NM_FOR_TARGET"; then
6066
  ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
6067
else
6068
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
6069
  ac_dummy="$PATH"
6070
  for ac_dir in $ac_dummy; do
6071
    test -z "$ac_dir" && ac_dir=.
6072
    if test -f $ac_dir/$ac_word; then
6073
      ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
6074
      break
6075
    fi
6076
  done
6077
  IFS="$ac_save_ifs"
6078
fi
6079
fi
6080
NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
6081
if test -n "$NM_FOR_TARGET"; then
6082
  echo "$ac_t""$NM_FOR_TARGET" 1>&6
6083
else
6084
  echo "$ac_t""no" 1>&6
6085
fi
6086
 
6087
    fi
6088
    if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
6089
      # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6090
set dummy ${ncn_progname}; ac_word=$2
6091
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
6092
echo "configure:6089: checking for $ac_word" >&5
6093
if eval "test \"`echo '$''{'ac_cv_prog_NM_FOR_TARGET'+set}'`\" = set"; then
6094
  echo $ac_n "(cached) $ac_c" 1>&6
6095
else
6096
  if test -n "$NM_FOR_TARGET"; then
6097
  ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
6098
else
6099
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
6100
  ac_dummy="$PATH"
6101
  for ac_dir in $ac_dummy; do
6102
    test -z "$ac_dir" && ac_dir=.
6103
    if test -f $ac_dir/$ac_word; then
6104
      ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
6105
      break
6106
    fi
6107
  done
6108
  IFS="$ac_save_ifs"
6109
fi
6110
fi
6111
NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
6112
if test -n "$NM_FOR_TARGET"; then
6113
  echo "$ac_t""$NM_FOR_TARGET" 1>&6
6114
else
6115
  echo "$ac_t""no" 1>&6
6116
fi
6117
 
6118
    fi
6119
    test -n "$ac_cv_prog_NM_FOR_TARGET" && break
6120
  done
6121
fi
6122
 
6123
if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
6124
  set dummy nm
6125
  if test $build = $target ; then
6126
    NM_FOR_TARGET="$2"
6127
  else
6128
    NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
6129
  fi
6130
else
6131
  NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
6132
fi
6133
 
6134
else
6135
  NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
6136
fi
6137
 
6138
 
6139
 
6140
 
6141
if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
6142
  if test -n "$with_build_time_tools"; then
6143
    echo $ac_n "checking for objdump in $with_build_time_tools""... $ac_c" 1>&6
6144
echo "configure:6141: checking for objdump in $with_build_time_tools" >&5
6145
    if test -x $with_build_time_tools/objdump; then
6146
      OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
6147
      ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
6148
      echo "$ac_t""$ac_cv_path_OBJDUMP_FOR_TARGET" 1>&6
6149
    else
6150
      echo "$ac_t""no" 1>&6
6151
    fi
6152
  elif test $build != $host && test $have_gcc_for_target = yes; then
6153
    OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
6154
    test $OBJDUMP_FOR_TARGET=objdump && OBJDUMP_FOR_TARGET=
6155
    test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
6156
  fi
6157
fi
6158
if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
6159
  # Extract the first word of "objdump", so it can be a program name with args.
6160
set dummy objdump; ac_word=$2
6161
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
6162
echo "configure:6159: checking for $ac_word" >&5
6163
if eval "test \"`echo '$''{'ac_cv_path_OBJDUMP_FOR_TARGET'+set}'`\" = set"; then
6164
  echo $ac_n "(cached) $ac_c" 1>&6
6165
else
6166
  case "$OBJDUMP_FOR_TARGET" in
6167
  /*)
6168
  ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
6169
  ;;
6170
  ?:/*)
6171
  ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a dos path.
6172
  ;;
6173
  *)
6174
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
6175
  ac_dummy="$gcc_cv_tool_dirs"
6176
  for ac_dir in $ac_dummy; do
6177
    test -z "$ac_dir" && ac_dir=.
6178
    if test -f $ac_dir/$ac_word; then
6179
      ac_cv_path_OBJDUMP_FOR_TARGET="$ac_dir/$ac_word"
6180
      break
6181
    fi
6182
  done
6183
  IFS="$ac_save_ifs"
6184
  ;;
6185
esac
6186
fi
6187
OBJDUMP_FOR_TARGET="$ac_cv_path_OBJDUMP_FOR_TARGET"
6188
if test -n "$OBJDUMP_FOR_TARGET"; then
6189
  echo "$ac_t""$OBJDUMP_FOR_TARGET" 1>&6
6190
else
6191
  echo "$ac_t""no" 1>&6
6192
fi
6193
 
6194
fi
6195
if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
6196
   if test -n "$with_build_time_tools"; then
6197
  for ncn_progname in objdump; do
6198
    echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
6199
echo "configure:6196: checking for ${ncn_progname} in $with_build_time_tools" >&5
6200
    if test -x $with_build_time_tools/${ncn_progname}; then
6201
      ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
6202
      echo "$ac_t""yes" 1>&6
6203
      break
6204
    else
6205
      echo "$ac_t""no" 1>&6
6206
    fi
6207
  done
6208
fi
6209
 
6210
if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
6211
  for ncn_progname in objdump; do
6212
    if test -n "$ncn_target_tool_prefix"; then
6213
      # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
6214
set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
6215
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
6216
echo "configure:6213: checking for $ac_word" >&5
6217
if eval "test \"`echo '$''{'ac_cv_prog_OBJDUMP_FOR_TARGET'+set}'`\" = set"; then
6218
  echo $ac_n "(cached) $ac_c" 1>&6
6219
else
6220
  if test -n "$OBJDUMP_FOR_TARGET"; then
6221
  ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
6222
else
6223
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
6224
  ac_dummy="$PATH"
6225
  for ac_dir in $ac_dummy; do
6226
    test -z "$ac_dir" && ac_dir=.
6227
    if test -f $ac_dir/$ac_word; then
6228
      ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
6229
      break
6230
    fi
6231
  done
6232
  IFS="$ac_save_ifs"
6233
fi
6234
fi
6235
OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
6236
if test -n "$OBJDUMP_FOR_TARGET"; then
6237
  echo "$ac_t""$OBJDUMP_FOR_TARGET" 1>&6
6238
else
6239
  echo "$ac_t""no" 1>&6
6240
fi
6241
 
6242
    fi
6243
    if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
6244
      # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6245
set dummy ${ncn_progname}; ac_word=$2
6246
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
6247
echo "configure:6244: checking for $ac_word" >&5
6248
if eval "test \"`echo '$''{'ac_cv_prog_OBJDUMP_FOR_TARGET'+set}'`\" = set"; then
6249
  echo $ac_n "(cached) $ac_c" 1>&6
6250
else
6251
  if test -n "$OBJDUMP_FOR_TARGET"; then
6252
  ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
6253
else
6254
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
6255
  ac_dummy="$PATH"
6256
  for ac_dir in $ac_dummy; do
6257
    test -z "$ac_dir" && ac_dir=.
6258
    if test -f $ac_dir/$ac_word; then
6259
      ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
6260
      break
6261
    fi
6262
  done
6263
  IFS="$ac_save_ifs"
6264
fi
6265
fi
6266
OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
6267
if test -n "$OBJDUMP_FOR_TARGET"; then
6268
  echo "$ac_t""$OBJDUMP_FOR_TARGET" 1>&6
6269
else
6270
  echo "$ac_t""no" 1>&6
6271
fi
6272
 
6273
    fi
6274
    test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
6275
  done
6276
fi
6277
 
6278
if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
6279
  set dummy objdump
6280
  if test $build = $target ; then
6281
    OBJDUMP_FOR_TARGET="$2"
6282
  else
6283
    OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
6284
  fi
6285
else
6286
  OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
6287
fi
6288
 
6289
else
6290
  OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
6291
fi
6292
 
6293
 
6294
 
6295
 
6296
if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
6297
  if test -n "$with_build_time_tools"; then
6298
    echo $ac_n "checking for ranlib in $with_build_time_tools""... $ac_c" 1>&6
6299
echo "configure:6296: checking for ranlib in $with_build_time_tools" >&5
6300
    if test -x $with_build_time_tools/ranlib; then
6301
      RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
6302
      ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
6303
      echo "$ac_t""$ac_cv_path_RANLIB_FOR_TARGET" 1>&6
6304
    else
6305
      echo "$ac_t""no" 1>&6
6306
    fi
6307
  elif test $build != $host && test $have_gcc_for_target = yes; then
6308
    RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
6309
    test $RANLIB_FOR_TARGET=ranlib && RANLIB_FOR_TARGET=
6310
    test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
6311
  fi
6312
fi
6313
if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
6314
  # Extract the first word of "ranlib", so it can be a program name with args.
6315
set dummy ranlib; ac_word=$2
6316
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
6317
echo "configure:6314: checking for $ac_word" >&5
6318
if eval "test \"`echo '$''{'ac_cv_path_RANLIB_FOR_TARGET'+set}'`\" = set"; then
6319
  echo $ac_n "(cached) $ac_c" 1>&6
6320
else
6321
  case "$RANLIB_FOR_TARGET" in
6322
  /*)
6323
  ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
6324
  ;;
6325
  ?:/*)
6326
  ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a dos path.
6327
  ;;
6328
  *)
6329
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
6330
  ac_dummy="$gcc_cv_tool_dirs"
6331
  for ac_dir in $ac_dummy; do
6332
    test -z "$ac_dir" && ac_dir=.
6333
    if test -f $ac_dir/$ac_word; then
6334
      ac_cv_path_RANLIB_FOR_TARGET="$ac_dir/$ac_word"
6335
      break
6336
    fi
6337
  done
6338
  IFS="$ac_save_ifs"
6339
  ;;
6340
esac
6341
fi
6342
RANLIB_FOR_TARGET="$ac_cv_path_RANLIB_FOR_TARGET"
6343
if test -n "$RANLIB_FOR_TARGET"; then
6344
  echo "$ac_t""$RANLIB_FOR_TARGET" 1>&6
6345
else
6346
  echo "$ac_t""no" 1>&6
6347
fi
6348
 
6349
fi
6350
if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
6351
   if test -n "$with_build_time_tools"; then
6352
  for ncn_progname in ranlib; do
6353
    echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
6354
echo "configure:6351: checking for ${ncn_progname} in $with_build_time_tools" >&5
6355
    if test -x $with_build_time_tools/${ncn_progname}; then
6356
      ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
6357
      echo "$ac_t""yes" 1>&6
6358
      break
6359
    else
6360
      echo "$ac_t""no" 1>&6
6361
    fi
6362
  done
6363
fi
6364
 
6365
if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
6366
  for ncn_progname in ranlib; do
6367
    if test -n "$ncn_target_tool_prefix"; then
6368
      # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
6369
set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
6370
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
6371
echo "configure:6368: checking for $ac_word" >&5
6372
if eval "test \"`echo '$''{'ac_cv_prog_RANLIB_FOR_TARGET'+set}'`\" = set"; then
6373
  echo $ac_n "(cached) $ac_c" 1>&6
6374
else
6375
  if test -n "$RANLIB_FOR_TARGET"; then
6376
  ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
6377
else
6378
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
6379
  ac_dummy="$PATH"
6380
  for ac_dir in $ac_dummy; do
6381
    test -z "$ac_dir" && ac_dir=.
6382
    if test -f $ac_dir/$ac_word; then
6383
      ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
6384
      break
6385
    fi
6386
  done
6387
  IFS="$ac_save_ifs"
6388
fi
6389
fi
6390
RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
6391
if test -n "$RANLIB_FOR_TARGET"; then
6392
  echo "$ac_t""$RANLIB_FOR_TARGET" 1>&6
6393
else
6394
  echo "$ac_t""no" 1>&6
6395
fi
6396
 
6397
    fi
6398
    if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
6399
      # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6400
set dummy ${ncn_progname}; ac_word=$2
6401
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
6402
echo "configure:6399: checking for $ac_word" >&5
6403
if eval "test \"`echo '$''{'ac_cv_prog_RANLIB_FOR_TARGET'+set}'`\" = set"; then
6404
  echo $ac_n "(cached) $ac_c" 1>&6
6405
else
6406
  if test -n "$RANLIB_FOR_TARGET"; then
6407
  ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
6408
else
6409
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
6410
  ac_dummy="$PATH"
6411
  for ac_dir in $ac_dummy; do
6412
    test -z "$ac_dir" && ac_dir=.
6413
    if test -f $ac_dir/$ac_word; then
6414
      ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
6415
      break
6416
    fi
6417
  done
6418
  IFS="$ac_save_ifs"
6419
fi
6420
fi
6421
RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
6422
if test -n "$RANLIB_FOR_TARGET"; then
6423
  echo "$ac_t""$RANLIB_FOR_TARGET" 1>&6
6424
else
6425
  echo "$ac_t""no" 1>&6
6426
fi
6427
 
6428
    fi
6429
    test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
6430
  done
6431
fi
6432
 
6433
if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
6434
  set dummy ranlib
6435
  if test $build = $target ; then
6436
    RANLIB_FOR_TARGET="$2"
6437
  else
6438
    RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
6439
  fi
6440
else
6441
  RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
6442
fi
6443
 
6444
else
6445
  RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
6446
fi
6447
 
6448
 
6449
 
6450
 
6451
if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
6452
  if test -n "$with_build_time_tools"; then
6453
    echo $ac_n "checking for strip in $with_build_time_tools""... $ac_c" 1>&6
6454
echo "configure:6451: checking for strip in $with_build_time_tools" >&5
6455
    if test -x $with_build_time_tools/strip; then
6456
      STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
6457
      ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
6458
      echo "$ac_t""$ac_cv_path_STRIP_FOR_TARGET" 1>&6
6459
    else
6460
      echo "$ac_t""no" 1>&6
6461
    fi
6462
  elif test $build != $host && test $have_gcc_for_target = yes; then
6463
    STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
6464
    test $STRIP_FOR_TARGET=strip && STRIP_FOR_TARGET=
6465
    test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
6466
  fi
6467
fi
6468
if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
6469
  # Extract the first word of "strip", so it can be a program name with args.
6470
set dummy strip; ac_word=$2
6471
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
6472
echo "configure:6469: checking for $ac_word" >&5
6473
if eval "test \"`echo '$''{'ac_cv_path_STRIP_FOR_TARGET'+set}'`\" = set"; then
6474
  echo $ac_n "(cached) $ac_c" 1>&6
6475
else
6476
  case "$STRIP_FOR_TARGET" in
6477
  /*)
6478
  ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
6479
  ;;
6480
  ?:/*)
6481
  ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a dos path.
6482
  ;;
6483
  *)
6484
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
6485
  ac_dummy="$gcc_cv_tool_dirs"
6486
  for ac_dir in $ac_dummy; do
6487
    test -z "$ac_dir" && ac_dir=.
6488
    if test -f $ac_dir/$ac_word; then
6489
      ac_cv_path_STRIP_FOR_TARGET="$ac_dir/$ac_word"
6490
      break
6491
    fi
6492
  done
6493
  IFS="$ac_save_ifs"
6494
  ;;
6495
esac
6496
fi
6497
STRIP_FOR_TARGET="$ac_cv_path_STRIP_FOR_TARGET"
6498
if test -n "$STRIP_FOR_TARGET"; then
6499
  echo "$ac_t""$STRIP_FOR_TARGET" 1>&6
6500
else
6501
  echo "$ac_t""no" 1>&6
6502
fi
6503
 
6504
fi
6505
if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
6506
   if test -n "$with_build_time_tools"; then
6507
  for ncn_progname in strip; do
6508
    echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
6509
echo "configure:6506: checking for ${ncn_progname} in $with_build_time_tools" >&5
6510
    if test -x $with_build_time_tools/${ncn_progname}; then
6511
      ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
6512
      echo "$ac_t""yes" 1>&6
6513
      break
6514
    else
6515
      echo "$ac_t""no" 1>&6
6516
    fi
6517
  done
6518
fi
6519
 
6520
if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
6521
  for ncn_progname in strip; do
6522
    if test -n "$ncn_target_tool_prefix"; then
6523
      # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
6524
set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
6525
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
6526
echo "configure:6523: checking for $ac_word" >&5
6527
if eval "test \"`echo '$''{'ac_cv_prog_STRIP_FOR_TARGET'+set}'`\" = set"; then
6528
  echo $ac_n "(cached) $ac_c" 1>&6
6529
else
6530
  if test -n "$STRIP_FOR_TARGET"; then
6531
  ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
6532
else
6533
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
6534
  ac_dummy="$PATH"
6535
  for ac_dir in $ac_dummy; do
6536
    test -z "$ac_dir" && ac_dir=.
6537
    if test -f $ac_dir/$ac_word; then
6538
      ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
6539
      break
6540
    fi
6541
  done
6542
  IFS="$ac_save_ifs"
6543
fi
6544
fi
6545
STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
6546
if test -n "$STRIP_FOR_TARGET"; then
6547
  echo "$ac_t""$STRIP_FOR_TARGET" 1>&6
6548
else
6549
  echo "$ac_t""no" 1>&6
6550
fi
6551
 
6552
    fi
6553
    if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
6554
      # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6555
set dummy ${ncn_progname}; ac_word=$2
6556
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
6557
echo "configure:6554: checking for $ac_word" >&5
6558
if eval "test \"`echo '$''{'ac_cv_prog_STRIP_FOR_TARGET'+set}'`\" = set"; then
6559
  echo $ac_n "(cached) $ac_c" 1>&6
6560
else
6561
  if test -n "$STRIP_FOR_TARGET"; then
6562
  ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
6563
else
6564
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
6565
  ac_dummy="$PATH"
6566
  for ac_dir in $ac_dummy; do
6567
    test -z "$ac_dir" && ac_dir=.
6568
    if test -f $ac_dir/$ac_word; then
6569
      ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
6570
      break
6571
    fi
6572
  done
6573
  IFS="$ac_save_ifs"
6574
fi
6575
fi
6576
STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
6577
if test -n "$STRIP_FOR_TARGET"; then
6578
  echo "$ac_t""$STRIP_FOR_TARGET" 1>&6
6579
else
6580
  echo "$ac_t""no" 1>&6
6581
fi
6582
 
6583
    fi
6584
    test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
6585
  done
6586
fi
6587
 
6588
if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
6589
  set dummy strip
6590
  if test $build = $target ; then
6591
    STRIP_FOR_TARGET="$2"
6592
  else
6593
    STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
6594
  fi
6595
else
6596
  STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
6597
fi
6598
 
6599
else
6600
  STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
6601
fi
6602
 
6603
 
6604
 
6605
 
6606
if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
6607
  if test -n "$with_build_time_tools"; then
6608
    echo $ac_n "checking for windres in $with_build_time_tools""... $ac_c" 1>&6
6609
echo "configure:6606: checking for windres in $with_build_time_tools" >&5
6610
    if test -x $with_build_time_tools/windres; then
6611
      WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
6612
      ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
6613
      echo "$ac_t""$ac_cv_path_WINDRES_FOR_TARGET" 1>&6
6614
    else
6615
      echo "$ac_t""no" 1>&6
6616
    fi
6617
  elif test $build != $host && test $have_gcc_for_target = yes; then
6618
    WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
6619
    test $WINDRES_FOR_TARGET=windres && WINDRES_FOR_TARGET=
6620
    test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
6621
  fi
6622
fi
6623
if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
6624
  # Extract the first word of "windres", so it can be a program name with args.
6625
set dummy windres; ac_word=$2
6626
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
6627
echo "configure:6624: checking for $ac_word" >&5
6628
if eval "test \"`echo '$''{'ac_cv_path_WINDRES_FOR_TARGET'+set}'`\" = set"; then
6629
  echo $ac_n "(cached) $ac_c" 1>&6
6630
else
6631
  case "$WINDRES_FOR_TARGET" in
6632
  /*)
6633
  ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
6634
  ;;
6635
  ?:/*)
6636
  ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a dos path.
6637
  ;;
6638
  *)
6639
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
6640
  ac_dummy="$gcc_cv_tool_dirs"
6641
  for ac_dir in $ac_dummy; do
6642
    test -z "$ac_dir" && ac_dir=.
6643
    if test -f $ac_dir/$ac_word; then
6644
      ac_cv_path_WINDRES_FOR_TARGET="$ac_dir/$ac_word"
6645
      break
6646
    fi
6647
  done
6648
  IFS="$ac_save_ifs"
6649
  ;;
6650
esac
6651
fi
6652
WINDRES_FOR_TARGET="$ac_cv_path_WINDRES_FOR_TARGET"
6653
if test -n "$WINDRES_FOR_TARGET"; then
6654
  echo "$ac_t""$WINDRES_FOR_TARGET" 1>&6
6655
else
6656
  echo "$ac_t""no" 1>&6
6657
fi
6658
 
6659
fi
6660
if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
6661
   if test -n "$with_build_time_tools"; then
6662
  for ncn_progname in windres; do
6663
    echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
6664
echo "configure:6661: checking for ${ncn_progname} in $with_build_time_tools" >&5
6665
    if test -x $with_build_time_tools/${ncn_progname}; then
6666
      ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
6667
      echo "$ac_t""yes" 1>&6
6668
      break
6669
    else
6670
      echo "$ac_t""no" 1>&6
6671
    fi
6672
  done
6673
fi
6674
 
6675
if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
6676
  for ncn_progname in windres; do
6677
    if test -n "$ncn_target_tool_prefix"; then
6678
      # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
6679
set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
6680
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
6681
echo "configure:6678: checking for $ac_word" >&5
6682
if eval "test \"`echo '$''{'ac_cv_prog_WINDRES_FOR_TARGET'+set}'`\" = set"; then
6683
  echo $ac_n "(cached) $ac_c" 1>&6
6684
else
6685
  if test -n "$WINDRES_FOR_TARGET"; then
6686
  ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
6687
else
6688
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
6689
  ac_dummy="$PATH"
6690
  for ac_dir in $ac_dummy; do
6691
    test -z "$ac_dir" && ac_dir=.
6692
    if test -f $ac_dir/$ac_word; then
6693
      ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
6694
      break
6695
    fi
6696
  done
6697
  IFS="$ac_save_ifs"
6698
fi
6699
fi
6700
WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
6701
if test -n "$WINDRES_FOR_TARGET"; then
6702
  echo "$ac_t""$WINDRES_FOR_TARGET" 1>&6
6703
else
6704
  echo "$ac_t""no" 1>&6
6705
fi
6706
 
6707
    fi
6708
    if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
6709
      # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6710
set dummy ${ncn_progname}; ac_word=$2
6711
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
6712
echo "configure:6709: checking for $ac_word" >&5
6713
if eval "test \"`echo '$''{'ac_cv_prog_WINDRES_FOR_TARGET'+set}'`\" = set"; then
6714
  echo $ac_n "(cached) $ac_c" 1>&6
6715
else
6716
  if test -n "$WINDRES_FOR_TARGET"; then
6717
  ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
6718
else
6719
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
6720
  ac_dummy="$PATH"
6721
  for ac_dir in $ac_dummy; do
6722
    test -z "$ac_dir" && ac_dir=.
6723
    if test -f $ac_dir/$ac_word; then
6724
      ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
6725
      break
6726
    fi
6727
  done
6728
  IFS="$ac_save_ifs"
6729
fi
6730
fi
6731
WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
6732
if test -n "$WINDRES_FOR_TARGET"; then
6733
  echo "$ac_t""$WINDRES_FOR_TARGET" 1>&6
6734
else
6735
  echo "$ac_t""no" 1>&6
6736
fi
6737
 
6738
    fi
6739
    test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
6740
  done
6741
fi
6742
 
6743
if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
6744
  set dummy windres
6745
  if test $build = $target ; then
6746
    WINDRES_FOR_TARGET="$2"
6747
  else
6748
    WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
6749
  fi
6750
else
6751
  WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
6752
fi
6753
 
6754
else
6755
  WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
6756
fi
6757
 
6758
 
6759
RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
6760
 
6761
echo $ac_n "checking where to find the target ar""... $ac_c" 1>&6
6762
echo "configure:6759: checking where to find the target ar" >&5
6763
if test "x${build}" != "x${host}" ; then
6764
  if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
6765
    # We already found the complete path
6766
    echo "$ac_t""pre-installed in `dirname $AR_FOR_TARGET`" 1>&6
6767
  else
6768
    # Canadian cross, just use what we found
6769
    echo "$ac_t""pre-installed" 1>&6
6770
  fi
6771
else
6772
  ok=yes
6773
  case " ${configdirs} " in
6774
    *" binutils "*) ;;
6775
    *) ok=no ;;
6776
  esac
6777
 
6778
  if test $ok = yes; then
6779
    # An in-tree tool is available and we can use it
6780
    AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
6781
    echo "$ac_t""just compiled" 1>&6
6782
  elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
6783
    # We already found the complete path
6784
    echo "$ac_t""pre-installed in `dirname $AR_FOR_TARGET`" 1>&6
6785
  elif test "x$target" = "x$host"; then
6786
    # We can use an host tool
6787
    AR_FOR_TARGET='$(AR)'
6788
    echo "$ac_t""host tool" 1>&6
6789
  else
6790
    # We need a cross tool
6791
    echo "$ac_t""pre-installed" 1>&6
6792
  fi
6793
fi
6794
echo $ac_n "checking where to find the target as""... $ac_c" 1>&6
6795
echo "configure:6792: checking where to find the target as" >&5
6796
if test "x${build}" != "x${host}" ; then
6797
  if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
6798
    # We already found the complete path
6799
    echo "$ac_t""pre-installed in `dirname $AS_FOR_TARGET`" 1>&6
6800
  else
6801
    # Canadian cross, just use what we found
6802
    echo "$ac_t""pre-installed" 1>&6
6803
  fi
6804
else
6805
  ok=yes
6806
  case " ${configdirs} " in
6807
    *" gas "*) ;;
6808
    *) ok=no ;;
6809
  esac
6810
 
6811
  if test $ok = yes; then
6812
    # An in-tree tool is available and we can use it
6813
    AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
6814
    echo "$ac_t""just compiled" 1>&6
6815
  elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
6816
    # We already found the complete path
6817
    echo "$ac_t""pre-installed in `dirname $AS_FOR_TARGET`" 1>&6
6818
  elif test "x$target" = "x$host"; then
6819
    # We can use an host tool
6820
    AS_FOR_TARGET='$(AS)'
6821
    echo "$ac_t""host tool" 1>&6
6822
  else
6823
    # We need a cross tool
6824
    echo "$ac_t""pre-installed" 1>&6
6825
  fi
6826
fi
6827
echo $ac_n "checking where to find the target cc""... $ac_c" 1>&6
6828
echo "configure:6825: checking where to find the target cc" >&5
6829
if test "x${build}" != "x${host}" ; then
6830
  if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
6831
    # We already found the complete path
6832
    echo "$ac_t""pre-installed in `dirname $CC_FOR_TARGET`" 1>&6
6833
  else
6834
    # Canadian cross, just use what we found
6835
    echo "$ac_t""pre-installed" 1>&6
6836
  fi
6837
else
6838
  ok=yes
6839
  case " ${configdirs} " in
6840
    *" gcc "*) ;;
6841
    *) ok=no ;;
6842
  esac
6843
 
6844
  if test $ok = yes; then
6845
    # An in-tree tool is available and we can use it
6846
    CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
6847
    echo "$ac_t""just compiled" 1>&6
6848
  elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
6849
    # We already found the complete path
6850
    echo "$ac_t""pre-installed in `dirname $CC_FOR_TARGET`" 1>&6
6851
  elif test "x$target" = "x$host"; then
6852
    # We can use an host tool
6853
    CC_FOR_TARGET='$(CC)'
6854
    echo "$ac_t""host tool" 1>&6
6855
  else
6856
    # We need a cross tool
6857
    echo "$ac_t""pre-installed" 1>&6
6858
  fi
6859
fi
6860
echo $ac_n "checking where to find the target c++""... $ac_c" 1>&6
6861
echo "configure:6858: checking where to find the target c++" >&5
6862
if test "x${build}" != "x${host}" ; then
6863
  if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
6864
    # We already found the complete path
6865
    echo "$ac_t""pre-installed in `dirname $CXX_FOR_TARGET`" 1>&6
6866
  else
6867
    # Canadian cross, just use what we found
6868
    echo "$ac_t""pre-installed" 1>&6
6869
  fi
6870
else
6871
  ok=yes
6872
  case " ${configdirs} " in
6873
    *" gcc "*) ;;
6874
    *) ok=no ;;
6875
  esac
6876
  case ,${enable_languages}, in
6877
    *,c++,*) ;;
6878
    *) ok=no ;;
6879
  esac
6880
  if test $ok = yes; then
6881
    # An in-tree tool is available and we can use it
6882
    CXX_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/g++ -B$$r/$(HOST_SUBDIR)/gcc/ -nostdinc++ `test ! -f $$r/$(TARGET_SUBDIR)/libstdc++-v3/scripts/testsuite_flags || $(SHELL) $$r/$(TARGET_SUBDIR)/libstdc++-v3/scripts/testsuite_flags --build-includes` -L$$r/$(TARGET_SUBDIR)/libstdc++-v3/src -L$$r/$(TARGET_SUBDIR)/libstdc++-v3/src/.libs'
6883
    echo "$ac_t""just compiled" 1>&6
6884
  elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
6885
    # We already found the complete path
6886
    echo "$ac_t""pre-installed in `dirname $CXX_FOR_TARGET`" 1>&6
6887
  elif test "x$target" = "x$host"; then
6888
    # We can use an host tool
6889
    CXX_FOR_TARGET='$(CXX)'
6890
    echo "$ac_t""host tool" 1>&6
6891
  else
6892
    # We need a cross tool
6893
    echo "$ac_t""pre-installed" 1>&6
6894
  fi
6895
fi
6896
echo $ac_n "checking where to find the target c++ for libstdc++""... $ac_c" 1>&6
6897
echo "configure:6894: checking where to find the target c++ for libstdc++" >&5
6898
if test "x${build}" != "x${host}" ; then
6899
  if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
6900
    # We already found the complete path
6901
    echo "$ac_t""pre-installed in `dirname $RAW_CXX_FOR_TARGET`" 1>&6
6902
  else
6903
    # Canadian cross, just use what we found
6904
    echo "$ac_t""pre-installed" 1>&6
6905
  fi
6906
else
6907
  ok=yes
6908
  case " ${configdirs} " in
6909
    *" gcc "*) ;;
6910
    *) ok=no ;;
6911
  esac
6912
  case ,${enable_languages}, in
6913
    *,c++,*) ;;
6914
    *) ok=no ;;
6915
  esac
6916
  if test $ok = yes; then
6917
    # An in-tree tool is available and we can use it
6918
    RAW_CXX_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -shared-libgcc -B$$r/$(HOST_SUBDIR)/gcc -nostdinc++ -L$$r/$(TARGET_SUBDIR)/libstdc++-v3/src -L$$r/$(TARGET_SUBDIR)/libstdc++-v3/src/.libs'
6919
    echo "$ac_t""just compiled" 1>&6
6920
  elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
6921
    # We already found the complete path
6922
    echo "$ac_t""pre-installed in `dirname $RAW_CXX_FOR_TARGET`" 1>&6
6923
  elif test "x$target" = "x$host"; then
6924
    # We can use an host tool
6925
    RAW_CXX_FOR_TARGET='$(CXX)'
6926
    echo "$ac_t""host tool" 1>&6
6927
  else
6928
    # We need a cross tool
6929
    echo "$ac_t""pre-installed" 1>&6
6930
  fi
6931
fi
6932
echo $ac_n "checking where to find the target dlltool""... $ac_c" 1>&6
6933
echo "configure:6930: checking where to find the target dlltool" >&5
6934
if test "x${build}" != "x${host}" ; then
6935
  if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
6936
    # We already found the complete path
6937
    echo "$ac_t""pre-installed in `dirname $DLLTOOL_FOR_TARGET`" 1>&6
6938
  else
6939
    # Canadian cross, just use what we found
6940
    echo "$ac_t""pre-installed" 1>&6
6941
  fi
6942
else
6943
  ok=yes
6944
  case " ${configdirs} " in
6945
    *" binutils "*) ;;
6946
    *) ok=no ;;
6947
  esac
6948
 
6949
  if test $ok = yes; then
6950
    # An in-tree tool is available and we can use it
6951
    DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
6952
    echo "$ac_t""just compiled" 1>&6
6953
  elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
6954
    # We already found the complete path
6955
    echo "$ac_t""pre-installed in `dirname $DLLTOOL_FOR_TARGET`" 1>&6
6956
  elif test "x$target" = "x$host"; then
6957
    # We can use an host tool
6958
    DLLTOOL_FOR_TARGET='$(DLLTOOL)'
6959
    echo "$ac_t""host tool" 1>&6
6960
  else
6961
    # We need a cross tool
6962
    echo "$ac_t""pre-installed" 1>&6
6963
  fi
6964
fi
6965
echo $ac_n "checking where to find the target gcc""... $ac_c" 1>&6
6966
echo "configure:6963: checking where to find the target gcc" >&5
6967
if test "x${build}" != "x${host}" ; then
6968
  if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
6969
    # We already found the complete path
6970
    echo "$ac_t""pre-installed in `dirname $GCC_FOR_TARGET`" 1>&6
6971
  else
6972
    # Canadian cross, just use what we found
6973
    echo "$ac_t""pre-installed" 1>&6
6974
  fi
6975
else
6976
  ok=yes
6977
  case " ${configdirs} " in
6978
    *" gcc "*) ;;
6979
    *) ok=no ;;
6980
  esac
6981
 
6982
  if test $ok = yes; then
6983
    # An in-tree tool is available and we can use it
6984
    GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
6985
    echo "$ac_t""just compiled" 1>&6
6986
  elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
6987
    # We already found the complete path
6988
    echo "$ac_t""pre-installed in `dirname $GCC_FOR_TARGET`" 1>&6
6989
  elif test "x$target" = "x$host"; then
6990
    # We can use an host tool
6991
    GCC_FOR_TARGET='$()'
6992
    echo "$ac_t""host tool" 1>&6
6993
  else
6994
    # We need a cross tool
6995
    echo "$ac_t""pre-installed" 1>&6
6996
  fi
6997
fi
6998
echo $ac_n "checking where to find the target gcj""... $ac_c" 1>&6
6999
echo "configure:6996: checking where to find the target gcj" >&5
7000
if test "x${build}" != "x${host}" ; then
7001
  if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
7002
    # We already found the complete path
7003
    echo "$ac_t""pre-installed in `dirname $GCJ_FOR_TARGET`" 1>&6
7004
  else
7005
    # Canadian cross, just use what we found
7006
    echo "$ac_t""pre-installed" 1>&6
7007
  fi
7008
else
7009
  ok=yes
7010
  case " ${configdirs} " in
7011
    *" gcc "*) ;;
7012
    *) ok=no ;;
7013
  esac
7014
  case ,${enable_languages}, in
7015
    *,java,*) ;;
7016
    *) ok=no ;;
7017
  esac
7018
  if test $ok = yes; then
7019
    # An in-tree tool is available and we can use it
7020
    GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
7021
    echo "$ac_t""just compiled" 1>&6
7022
  elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
7023
    # We already found the complete path
7024
    echo "$ac_t""pre-installed in `dirname $GCJ_FOR_TARGET`" 1>&6
7025
  elif test "x$target" = "x$host"; then
7026
    # We can use an host tool
7027
    GCJ_FOR_TARGET='$(GCJ)'
7028
    echo "$ac_t""host tool" 1>&6
7029
  else
7030
    # We need a cross tool
7031
    echo "$ac_t""pre-installed" 1>&6
7032
  fi
7033
fi
7034
echo $ac_n "checking where to find the target gfortran""... $ac_c" 1>&6
7035
echo "configure:7032: checking where to find the target gfortran" >&5
7036
if test "x${build}" != "x${host}" ; then
7037
  if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
7038
    # We already found the complete path
7039
    echo "$ac_t""pre-installed in `dirname $GFORTRAN_FOR_TARGET`" 1>&6
7040
  else
7041
    # Canadian cross, just use what we found
7042
    echo "$ac_t""pre-installed" 1>&6
7043
  fi
7044
else
7045
  ok=yes
7046
  case " ${configdirs} " in
7047
    *" gcc "*) ;;
7048
    *) ok=no ;;
7049
  esac
7050
  case ,${enable_languages}, in
7051
    *,fortran,*) ;;
7052
    *) ok=no ;;
7053
  esac
7054
  if test $ok = yes; then
7055
    # An in-tree tool is available and we can use it
7056
    GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
7057
    echo "$ac_t""just compiled" 1>&6
7058
  elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
7059
    # We already found the complete path
7060
    echo "$ac_t""pre-installed in `dirname $GFORTRAN_FOR_TARGET`" 1>&6
7061
  elif test "x$target" = "x$host"; then
7062
    # We can use an host tool
7063
    GFORTRAN_FOR_TARGET='$(GFORTRAN)'
7064
    echo "$ac_t""host tool" 1>&6
7065
  else
7066
    # We need a cross tool
7067
    echo "$ac_t""pre-installed" 1>&6
7068
  fi
7069
fi
7070
echo $ac_n "checking where to find the target ld""... $ac_c" 1>&6
7071
echo "configure:7068: checking where to find the target ld" >&5
7072
if test "x${build}" != "x${host}" ; then
7073
  if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
7074
    # We already found the complete path
7075
    echo "$ac_t""pre-installed in `dirname $LD_FOR_TARGET`" 1>&6
7076
  else
7077
    # Canadian cross, just use what we found
7078
    echo "$ac_t""pre-installed" 1>&6
7079
  fi
7080
else
7081
  ok=yes
7082
  case " ${configdirs} " in
7083
    *" ld "*) ;;
7084
    *) ok=no ;;
7085
  esac
7086
 
7087
  if test $ok = yes; then
7088
    # An in-tree tool is available and we can use it
7089
    LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
7090
    echo "$ac_t""just compiled" 1>&6
7091
  elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
7092
    # We already found the complete path
7093
    echo "$ac_t""pre-installed in `dirname $LD_FOR_TARGET`" 1>&6
7094
  elif test "x$target" = "x$host"; then
7095
    # We can use an host tool
7096
    LD_FOR_TARGET='$(LD)'
7097
    echo "$ac_t""host tool" 1>&6
7098
  else
7099
    # We need a cross tool
7100
    echo "$ac_t""pre-installed" 1>&6
7101
  fi
7102
fi
7103
echo $ac_n "checking where to find the target lipo""... $ac_c" 1>&6
7104
echo "configure:7101: checking where to find the target lipo" >&5
7105
if test "x${build}" != "x${host}" ; then
7106
  if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
7107
    # We already found the complete path
7108
    echo "$ac_t""pre-installed in `dirname $LIPO_FOR_TARGET`" 1>&6
7109
  else
7110
    # Canadian cross, just use what we found
7111
    echo "$ac_t""pre-installed" 1>&6
7112
  fi
7113
else
7114
  if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
7115
    # We already found the complete path
7116
    echo "$ac_t""pre-installed in `dirname $LIPO_FOR_TARGET`" 1>&6
7117
  elif test "x$target" = "x$host"; then
7118
    # We can use an host tool
7119
    LIPO_FOR_TARGET='$(LIPO)'
7120
    echo "$ac_t""host tool" 1>&6
7121
  else
7122
    # We need a cross tool
7123
    echo "$ac_t""pre-installed" 1>&6
7124
  fi
7125
fi
7126
echo $ac_n "checking where to find the target nm""... $ac_c" 1>&6
7127
echo "configure:7124: checking where to find the target nm" >&5
7128
if test "x${build}" != "x${host}" ; then
7129
  if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
7130
    # We already found the complete path
7131
    echo "$ac_t""pre-installed in `dirname $NM_FOR_TARGET`" 1>&6
7132
  else
7133
    # Canadian cross, just use what we found
7134
    echo "$ac_t""pre-installed" 1>&6
7135
  fi
7136
else
7137
  ok=yes
7138
  case " ${configdirs} " in
7139
    *" binutils "*) ;;
7140
    *) ok=no ;;
7141
  esac
7142
 
7143
  if test $ok = yes; then
7144
    # An in-tree tool is available and we can use it
7145
    NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
7146
    echo "$ac_t""just compiled" 1>&6
7147
  elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
7148
    # We already found the complete path
7149
    echo "$ac_t""pre-installed in `dirname $NM_FOR_TARGET`" 1>&6
7150
  elif test "x$target" = "x$host"; then
7151
    # We can use an host tool
7152
    NM_FOR_TARGET='$(NM)'
7153
    echo "$ac_t""host tool" 1>&6
7154
  else
7155
    # We need a cross tool
7156
    echo "$ac_t""pre-installed" 1>&6
7157
  fi
7158
fi
7159
echo $ac_n "checking where to find the target objdump""... $ac_c" 1>&6
7160
echo "configure:7157: checking where to find the target objdump" >&5
7161
if test "x${build}" != "x${host}" ; then
7162
  if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
7163
    # We already found the complete path
7164
    echo "$ac_t""pre-installed in `dirname $OBJDUMP_FOR_TARGET`" 1>&6
7165
  else
7166
    # Canadian cross, just use what we found
7167
    echo "$ac_t""pre-installed" 1>&6
7168
  fi
7169
else
7170
  ok=yes
7171
  case " ${configdirs} " in
7172
    *" binutils "*) ;;
7173
    *) ok=no ;;
7174
  esac
7175
 
7176
  if test $ok = yes; then
7177
    # An in-tree tool is available and we can use it
7178
    OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
7179
    echo "$ac_t""just compiled" 1>&6
7180
  elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
7181
    # We already found the complete path
7182
    echo "$ac_t""pre-installed in `dirname $OBJDUMP_FOR_TARGET`" 1>&6
7183
  elif test "x$target" = "x$host"; then
7184
    # We can use an host tool
7185
    OBJDUMP_FOR_TARGET='$(OBJDUMP)'
7186
    echo "$ac_t""host tool" 1>&6
7187
  else
7188
    # We need a cross tool
7189
    echo "$ac_t""pre-installed" 1>&6
7190
  fi
7191
fi
7192
echo $ac_n "checking where to find the target ranlib""... $ac_c" 1>&6
7193
echo "configure:7190: checking where to find the target ranlib" >&5
7194
if test "x${build}" != "x${host}" ; then
7195
  if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
7196
    # We already found the complete path
7197
    echo "$ac_t""pre-installed in `dirname $RANLIB_FOR_TARGET`" 1>&6
7198
  else
7199
    # Canadian cross, just use what we found
7200
    echo "$ac_t""pre-installed" 1>&6
7201
  fi
7202
else
7203
  ok=yes
7204
  case " ${configdirs} " in
7205
    *" binutils "*) ;;
7206
    *) ok=no ;;
7207
  esac
7208
 
7209
  if test $ok = yes; then
7210
    # An in-tree tool is available and we can use it
7211
    RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
7212
    echo "$ac_t""just compiled" 1>&6
7213
  elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
7214
    # We already found the complete path
7215
    echo "$ac_t""pre-installed in `dirname $RANLIB_FOR_TARGET`" 1>&6
7216
  elif test "x$target" = "x$host"; then
7217
    # We can use an host tool
7218
    RANLIB_FOR_TARGET='$(RANLIB)'
7219
    echo "$ac_t""host tool" 1>&6
7220
  else
7221
    # We need a cross tool
7222
    echo "$ac_t""pre-installed" 1>&6
7223
  fi
7224
fi
7225
echo $ac_n "checking where to find the target strip""... $ac_c" 1>&6
7226
echo "configure:7223: checking where to find the target strip" >&5
7227
if test "x${build}" != "x${host}" ; then
7228
  if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
7229
    # We already found the complete path
7230
    echo "$ac_t""pre-installed in `dirname $STRIP_FOR_TARGET`" 1>&6
7231
  else
7232
    # Canadian cross, just use what we found
7233
    echo "$ac_t""pre-installed" 1>&6
7234
  fi
7235
else
7236
  ok=yes
7237
  case " ${configdirs} " in
7238
    *" binutils "*) ;;
7239
    *) ok=no ;;
7240
  esac
7241
 
7242
  if test $ok = yes; then
7243
    # An in-tree tool is available and we can use it
7244
    STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
7245
    echo "$ac_t""just compiled" 1>&6
7246
  elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
7247
    # We already found the complete path
7248
    echo "$ac_t""pre-installed in `dirname $STRIP_FOR_TARGET`" 1>&6
7249
  elif test "x$target" = "x$host"; then
7250
    # We can use an host tool
7251
    STRIP_FOR_TARGET='$(STRIP)'
7252
    echo "$ac_t""host tool" 1>&6
7253
  else
7254
    # We need a cross tool
7255
    echo "$ac_t""pre-installed" 1>&6
7256
  fi
7257
fi
7258
echo $ac_n "checking where to find the target windres""... $ac_c" 1>&6
7259
echo "configure:7256: checking where to find the target windres" >&5
7260
if test "x${build}" != "x${host}" ; then
7261
  if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
7262
    # We already found the complete path
7263
    echo "$ac_t""pre-installed in `dirname $WINDRES_FOR_TARGET`" 1>&6
7264
  else
7265
    # Canadian cross, just use what we found
7266
    echo "$ac_t""pre-installed" 1>&6
7267
  fi
7268
else
7269
  ok=yes
7270
  case " ${configdirs} " in
7271
    *" binutils "*) ;;
7272
    *) ok=no ;;
7273
  esac
7274
 
7275
  if test $ok = yes; then
7276
    # An in-tree tool is available and we can use it
7277
    WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
7278
    echo "$ac_t""just compiled" 1>&6
7279
  elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
7280
    # We already found the complete path
7281
    echo "$ac_t""pre-installed in `dirname $WINDRES_FOR_TARGET`" 1>&6
7282
  elif test "x$target" = "x$host"; then
7283
    # We can use an host tool
7284
    WINDRES_FOR_TARGET='$(WINDRES)'
7285
    echo "$ac_t""host tool" 1>&6
7286
  else
7287
    # We need a cross tool
7288
    echo "$ac_t""pre-installed" 1>&6
7289
  fi
7290
fi
7291
 
7292
 
7293
 
7294
 
7295
# Certain tools may need extra flags.
7296
AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
7297
RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
7298
NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
7299
 
7300
# When building target libraries, except in a Canadian cross, we use
7301
# the same toolchain as the compiler we just built.
7302
COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
7303
COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
7304
COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
7305
if test $host = $build; then
7306
  case " $configdirs " in
7307
    *" gcc "*)
7308
      COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
7309
      COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
7310
      COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
7311
      ;;
7312
  esac
7313
fi
7314
 
7315
 
7316
 
7317
 
7318
 
7319
echo $ac_n "checking whether to enable maintainer-specific portions of Makefiles""... $ac_c" 1>&6
7320
echo "configure:7317: checking whether to enable maintainer-specific portions of Makefiles" >&5
7321
# Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
7322
if test "${enable_maintainer_mode+set}" = set; then
7323
  enableval="$enable_maintainer_mode"
7324
  USE_MAINTAINER_MODE=$enableval
7325
else
7326
  USE_MAINTAINER_MODE=no
7327
fi
7328
 
7329
echo "$ac_t""$USE_MAINTAINER_MODE" 1>&6
7330
 
7331
 
7332
if test "$USE_MAINTAINER_MODE" = yes; then
7333
  MAINTAINER_MODE_TRUE=
7334
  MAINTAINER_MODE_FALSE='#'
7335
else
7336
  MAINTAINER_MODE_TRUE='#'
7337
  MAINTAINER_MODE_FALSE=
7338
fi
7339
MAINT=$MAINTAINER_MODE_TRUE
7340
 
7341
# ---------------------
7342
# GCC bootstrap support
7343
# ---------------------
7344
 
7345
# Stage specific cflags for build.
7346
stage1_cflags="-g"
7347
case $build in
7348
  vax-*-*)
7349
    case ${GCC} in
7350
      yes) stage1_cflags="-g -Wa,-J" ;;
7351
      *) stage1_cflags="-g -J" ;;
7352
    esac ;;
7353
  powerpc-*-darwin*)
7354
    # The spiffy cpp-precomp chokes on some legitimate constructs in GCC
7355
    # sources; use -no-cpp-precomp to get to GNU cpp.
7356
    # Apple's GCC has bugs in designated initializer handling, so disable
7357
    # that too.
7358
    stage1_cflags="-g -no-cpp-precomp -DHAVE_DESIGNATED_INITIALIZERS=0"
7359
    ;;
7360
esac
7361
 
7362
# This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
7363
if test "$GCC" = yes; then
7364
  saved_CFLAGS="$CFLAGS"
7365
 
7366
  # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
7367
  CFLAGS="$CFLAGS -fkeep-inline-functions"
7368
  echo $ac_n "checking whether -fkeep-inline-functions is supported""... $ac_c" 1>&6
7369
echo "configure:7366: checking whether -fkeep-inline-functions is supported" >&5
7370
  cat > conftest.$ac_ext <
7371
#line 7368 "configure"
7372
#include "confdefs.h"
7373
 
7374
#if (__GNUC__ < 3) \
7375
    || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
7376
                          || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
7377
#error http://gcc.gnu.org/PR29382
7378
#endif
7379
 
7380
int main() {
7381
 
7382
; return 0; }
7383
EOF
7384
if { (eval echo configure:7381: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7385
  rm -rf conftest*
7386
  echo "$ac_t""yes" 1>&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
7387
else
7388
  echo "configure: failed program was:" >&5
7389
  cat conftest.$ac_ext >&5
7390
  rm -rf conftest*
7391
  echo "$ac_t""no" 1>&6
7392
fi
7393
rm -f conftest*
7394
 
7395
  CFLAGS="$saved_CFLAGS"
7396
fi
7397
 
7398
 
7399
 
7400
# Enable --enable-checking in stage1 of the compiler.
7401
# Check whether --enable-stage1-checking or --disable-stage1-checking was given.
7402
if test "${enable_stage1_checking+set}" = set; then
7403
  enableval="$enable_stage1_checking"
7404
  stage1_checking=--enable-checking=${enable_stage1_checking}
7405
else
7406
  if test "x$enable_checking" = xno; then
7407
  stage1_checking=--enable-checking
7408
else
7409
  stage1_checking=--enable-checking${enable_checking+=}$enable_checking
7410
fi
7411
fi
7412
 
7413
 
7414
 
7415
# Enable -Werror in bootstrap stage2 and later.
7416
# Check whether --enable-werror or --disable-werror was given.
7417
if test "${enable_werror+set}" = set; then
7418
  enableval="$enable_werror"
7419
  :
7420
else
7421
  if test -d gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
7422
  enable_werror=yes
7423
else
7424
  enable_werror=no
7425
fi
7426
fi
7427
 
7428
case ${enable_werror} in
7429
  yes) stage2_werror_flag="--enable-werror-always" ;;
7430
  *) stage2_werror_flag="" ;;
7431
esac
7432
 
7433
 
7434
# Flags needed to enable html installing and building
7435
# Check whether --with-datarootdir or --without-datarootdir was given.
7436
if test "${with_datarootdir+set}" = set; then
7437
  withval="$with_datarootdir"
7438
  datarootdir="\${prefix}/${withval}"
7439
else
7440
  datarootdir="\${prefix}/share"
7441
fi
7442
 
7443
 
7444
# Check whether --with-docdir or --without-docdir was given.
7445
if test "${with_docdir+set}" = set; then
7446
  withval="$with_docdir"
7447
  docdir="\${prefix}/${withval}"
7448
else
7449
  docdir="\${datarootdir}/doc"
7450
fi
7451
 
7452
 
7453
# Check whether --with-htmldir or --without-htmldir was given.
7454
if test "${with_htmldir+set}" = set; then
7455
  withval="$with_htmldir"
7456
  htmldir="\${prefix}/${withval}"
7457
else
7458
  htmldir="\${docdir}"
7459
fi
7460
 
7461
 
7462
 
7463
 
7464
 
7465
 
7466
trap '' 1 2 15
7467
cat > confcache <<\EOF
7468
# This file is a shell script that caches the results of configure
7469
# tests run on this system so they can be shared between configure
7470
# scripts and configure runs.  It is not useful on other systems.
7471
# If it contains results you don't want to keep, you may remove or edit it.
7472
#
7473
# By default, configure uses ./config.cache as the cache file,
7474
# creating it if it does not exist already.  You can give configure
7475
# the --cache-file=FILE option to use a different cache file; that is
7476
# what configure does when it calls configure scripts in
7477
# subdirectories, so they share the cache.
7478
# Giving --cache-file=/dev/null disables caching, for debugging configure.
7479
# config.status only pays attention to the cache file if you give it the
7480
# --recheck option to rerun configure.
7481
#
7482
EOF
7483
# The following way of writing the cache mishandles newlines in values,
7484
# but we know of no workaround that is simple, portable, and efficient.
7485
# So, don't put newlines in cache variables' values.
7486
# Ultrix sh set writes to stderr and can't be redirected directly,
7487
# and sets the high bit in the cache file unless we assign to the vars.
7488
(set) 2>&1 |
7489
  case `(ac_space=' '; set | grep ac_space) 2>&1` in
7490
  *ac_space=\ *)
7491
    # `set' does not quote correctly, so add quotes (double-quote substitution
7492
    # turns \\\\ into \\, and sed turns \\ into \).
7493
    sed -n \
7494
      -e "s/'/'\\\\''/g" \
7495
      -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
7496
    ;;
7497
  *)
7498
    # `set' quotes correctly as required by POSIX, so do not add quotes.
7499
    sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
7500
    ;;
7501
  esac >> confcache
7502
if cmp -s $cache_file confcache; then
7503
  :
7504
else
7505
  if test -w $cache_file; then
7506
    echo "updating cache $cache_file"
7507
    cat confcache > $cache_file
7508
  else
7509
    echo "not updating unwritable cache $cache_file"
7510
  fi
7511
fi
7512
rm -f confcache
7513
 
7514
trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15
7515
 
7516
test "x$prefix" = xNONE && prefix=$ac_default_prefix
7517
# Let make expand exec_prefix.
7518
test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
7519
 
7520
# Any assignment to VPATH causes Sun make to only execute
7521
# the first set of double-colon rules, so remove it if not needed.
7522
# If there is a colon in the path, we need to keep it.
7523
if test "x$srcdir" = x.; then
7524
  ac_vpsub='/^[         ]*VPATH[        ]*=[^:]*$/d'
7525
fi
7526
 
7527
trap 'rm -f $CONFIG_STATUS conftest*; exit 1' 1 2 15
7528
 
7529
# Transform confdefs.h into DEFS.
7530
# Protect against shell expansion while executing Makefile rules.
7531
# Protect against Makefile macro expansion.
7532
cat > conftest.defs <<\EOF
7533
s%#define \([A-Za-z_][A-Za-z0-9_]*\) *\(.*\)%-D\1=\2%g
7534
s%[     `~#$^&*(){}\\|;'"<>?]%\\&%g
7535
s%\[%\\&%g
7536
s%\]%\\&%g
7537
s%\$%$$%g
7538
EOF
7539
DEFS=`sed -f conftest.defs confdefs.h | tr '\012' ' '`
7540
rm -f conftest.defs
7541
 
7542
 
7543
# Without the "./", some shells look in PATH for config.status.
7544
: ${CONFIG_STATUS=./config.status}
7545
 
7546
echo creating $CONFIG_STATUS
7547
rm -f $CONFIG_STATUS
7548
cat > $CONFIG_STATUS <
7549
#! /bin/sh
7550
# Generated automatically by configure.
7551
# Run this file to recreate the current configuration.
7552
# This directory was configured as follows,
7553
# on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
7554
#
7555
# $0 $ac_configure_args
7556
#
7557
# Compiler output produced by configure, useful for debugging
7558
# configure, is in ./config.log if it exists.
7559
 
7560
ac_cs_usage="Usage: $CONFIG_STATUS [--recheck] [--version] [--help]"
7561
for ac_option
7562
do
7563
  case "\$ac_option" in
7564
  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
7565
    echo "running \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion"
7566
    exec \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion ;;
7567
  -version | --version | --versio | --versi | --vers | --ver | --ve | --v)
7568
    echo "$CONFIG_STATUS generated by autoconf version 2.13"
7569
    exit 0 ;;
7570
  -help | --help | --hel | --he | --h)
7571
    echo "\$ac_cs_usage"; exit 0 ;;
7572
  *) echo "\$ac_cs_usage"; exit 1 ;;
7573
  esac
7574
done
7575
 
7576
ac_given_srcdir=$srcdir
7577
ac_given_INSTALL="$INSTALL"
7578
 
7579
trap 'rm -fr `echo "Makefile" | sed "s/:[^ ]*//g"` conftest*; exit 1' 1 2 15
7580
EOF
7581
cat >> $CONFIG_STATUS <
7582
 
7583
# Protect against being on the right side of a sed subst in config.status.
7584
sed 's/%@/@@/; s/@%/@@/; s/%g\$/@g/; /@g\$/s/[\\\\&%]/\\\\&/g;
7585
 s/@@/%@/; s/@@/@%/; s/@g\$/%g/' > conftest.subs <<\\CEOF
7586
$ac_vpsub
7587
$extrasub
7588
s%@SHELL@%$SHELL%g
7589
s%@CFLAGS@%$CFLAGS%g
7590
s%@CPPFLAGS@%$CPPFLAGS%g
7591
s%@CXXFLAGS@%$CXXFLAGS%g
7592
s%@FFLAGS@%$FFLAGS%g
7593
s%@DEFS@%$DEFS%g
7594
s%@LDFLAGS@%$LDFLAGS%g
7595
s%@LIBS@%$LIBS%g
7596
s%@exec_prefix@%$exec_prefix%g
7597
s%@prefix@%$prefix%g
7598
s%@program_transform_name@%$program_transform_name%g
7599
s%@bindir@%$bindir%g
7600
s%@sbindir@%$sbindir%g
7601
s%@libexecdir@%$libexecdir%g
7602
s%@datadir@%$datadir%g
7603
s%@sysconfdir@%$sysconfdir%g
7604
s%@sharedstatedir@%$sharedstatedir%g
7605
s%@localstatedir@%$localstatedir%g
7606
s%@libdir@%$libdir%g
7607
s%@includedir@%$includedir%g
7608
s%@oldincludedir@%$oldincludedir%g
7609
s%@infodir@%$infodir%g
7610
s%@mandir@%$mandir%g
7611
s%@host@%$host%g
7612
s%@host_alias@%$host_alias%g
7613
s%@host_cpu@%$host_cpu%g
7614
s%@host_vendor@%$host_vendor%g
7615
s%@host_os@%$host_os%g
7616
s%@target@%$target%g
7617
s%@target_alias@%$target_alias%g
7618
s%@target_cpu@%$target_cpu%g
7619
s%@target_vendor@%$target_vendor%g
7620
s%@target_os@%$target_os%g
7621
s%@build@%$build%g
7622
s%@build_alias@%$build_alias%g
7623
s%@build_cpu@%$build_cpu%g
7624
s%@build_vendor@%$build_vendor%g
7625
s%@build_os@%$build_os%g
7626
s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g
7627
s%@INSTALL_SCRIPT@%$INSTALL_SCRIPT%g
7628
s%@INSTALL_DATA@%$INSTALL_DATA%g
7629
s%@LN@%$LN%g
7630
s%@LN_S@%$LN_S%g
7631
s%@TOPLEVEL_CONFIGURE_ARGUMENTS@%$TOPLEVEL_CONFIGURE_ARGUMENTS%g
7632
s%@build_libsubdir@%$build_libsubdir%g
7633
s%@build_subdir@%$build_subdir%g
7634
s%@host_subdir@%$host_subdir%g
7635
s%@target_subdir@%$target_subdir%g
7636
s%@CC@%$CC%g
7637
s%@GNATBIND@%$GNATBIND%g
7638
s%@do_compare@%$do_compare%g
7639
s%@gmplibs@%$gmplibs%g
7640
s%@gmpinc@%$gmpinc%g
7641
s%@stage1_languages@%$stage1_languages%g
7642
s%@SYSROOT_CFLAGS_FOR_TARGET@%$SYSROOT_CFLAGS_FOR_TARGET%g
7643
/@serialization_dependencies@/r $serialization_dependencies
7644
s%@serialization_dependencies@%%g
7645
/@host_makefile_frag@/r $host_makefile_frag
7646
s%@host_makefile_frag@%%g
7647
/@target_makefile_frag@/r $target_makefile_frag
7648
s%@target_makefile_frag@%%g
7649
/@alphaieee_frag@/r $alphaieee_frag
7650
s%@alphaieee_frag@%%g
7651
/@ospace_frag@/r $ospace_frag
7652
s%@ospace_frag@%%g
7653
s%@RPATH_ENVVAR@%$RPATH_ENVVAR%g
7654
s%@tooldir@%$tooldir%g
7655
s%@build_tooldir@%$build_tooldir%g
7656
s%@CONFIGURE_GDB_TK@%$CONFIGURE_GDB_TK%g
7657
s%@GDB_TK@%$GDB_TK%g
7658
s%@INSTALL_GDB_TK@%$INSTALL_GDB_TK%g
7659
s%@build_configargs@%$build_configargs%g
7660
s%@build_configdirs@%$build_configdirs%g
7661
s%@host_configargs@%$host_configargs%g
7662
s%@configdirs@%$configdirs%g
7663
s%@target_configargs@%$target_configargs%g
7664
s%@CC_FOR_BUILD@%$CC_FOR_BUILD%g
7665
s%@config_shell@%$config_shell%g
7666
s%@YACC@%$YACC%g
7667
s%@BISON@%$BISON%g
7668
s%@M4@%$M4%g
7669
s%@LEX@%$LEX%g
7670
s%@FLEX@%$FLEX%g
7671
s%@MAKEINFO@%$MAKEINFO%g
7672
s%@EXPECT@%$EXPECT%g
7673
s%@RUNTEST@%$RUNTEST%g
7674
s%@AR@%$AR%g
7675
s%@AS@%$AS%g
7676
s%@DLLTOOL@%$DLLTOOL%g
7677
s%@LD@%$LD%g
7678
s%@LIPO@%$LIPO%g
7679
s%@NM@%$NM%g
7680
s%@RANLIB@%$RANLIB%g
7681
s%@STRIP@%$STRIP%g
7682
s%@WINDRES@%$WINDRES%g
7683
s%@OBJCOPY@%$OBJCOPY%g
7684
s%@OBJDUMP@%$OBJDUMP%g
7685
s%@CXX@%$CXX%g
7686
s%@CFLAGS_FOR_BUILD@%$CFLAGS_FOR_BUILD%g
7687
s%@CC_FOR_TARGET@%$CC_FOR_TARGET%g
7688
s%@CXX_FOR_TARGET@%$CXX_FOR_TARGET%g
7689
s%@GCC_FOR_TARGET@%$GCC_FOR_TARGET%g
7690
s%@GCJ_FOR_TARGET@%$GCJ_FOR_TARGET%g
7691
s%@GFORTRAN_FOR_TARGET@%$GFORTRAN_FOR_TARGET%g
7692
s%@AR_FOR_TARGET@%$AR_FOR_TARGET%g
7693
s%@AS_FOR_TARGET@%$AS_FOR_TARGET%g
7694
s%@DLLTOOL_FOR_TARGET@%$DLLTOOL_FOR_TARGET%g
7695
s%@LD_FOR_TARGET@%$LD_FOR_TARGET%g
7696
s%@LIPO_FOR_TARGET@%$LIPO_FOR_TARGET%g
7697
s%@NM_FOR_TARGET@%$NM_FOR_TARGET%g
7698
s%@OBJDUMP_FOR_TARGET@%$OBJDUMP_FOR_TARGET%g
7699
s%@RANLIB_FOR_TARGET@%$RANLIB_FOR_TARGET%g
7700
s%@STRIP_FOR_TARGET@%$STRIP_FOR_TARGET%g
7701
s%@WINDRES_FOR_TARGET@%$WINDRES_FOR_TARGET%g
7702
s%@FLAGS_FOR_TARGET@%$FLAGS_FOR_TARGET%g
7703
s%@RAW_CXX_FOR_TARGET@%$RAW_CXX_FOR_TARGET%g
7704
s%@COMPILER_AS_FOR_TARGET@%$COMPILER_AS_FOR_TARGET%g
7705
s%@COMPILER_LD_FOR_TARGET@%$COMPILER_LD_FOR_TARGET%g
7706
s%@COMPILER_NM_FOR_TARGET@%$COMPILER_NM_FOR_TARGET%g
7707
s%@MAINTAINER_MODE_TRUE@%$MAINTAINER_MODE_TRUE%g
7708
s%@MAINTAINER_MODE_FALSE@%$MAINTAINER_MODE_FALSE%g
7709
s%@MAINT@%$MAINT%g
7710
s%@stage1_cflags@%$stage1_cflags%g
7711
s%@stage1_checking@%$stage1_checking%g
7712
s%@stage2_werror_flag@%$stage2_werror_flag%g
7713
s%@datarootdir@%$datarootdir%g
7714
s%@docdir@%$docdir%g
7715
s%@htmldir@%$htmldir%g
7716
 
7717
CEOF
7718
EOF
7719
 
7720
cat >> $CONFIG_STATUS <<\EOF
7721
 
7722
# Split the substitutions into bite-sized pieces for seds with
7723
# small command number limits, like on Digital OSF/1 and HP-UX.
7724
ac_max_sed_cmds=90 # Maximum number of lines to put in a sed script.
7725
ac_file=1 # Number of current file.
7726
ac_beg=1 # First line for current file.
7727
ac_end=$ac_max_sed_cmds # Line after last line for current file.
7728
ac_more_lines=:
7729
ac_sed_cmds=""
7730
while $ac_more_lines; do
7731
  if test $ac_beg -gt 1; then
7732
    sed "1,${ac_beg}d; ${ac_end}q" conftest.subs > conftest.s$ac_file
7733
  else
7734
    sed "${ac_end}q" conftest.subs > conftest.s$ac_file
7735
  fi
7736
  if test ! -s conftest.s$ac_file; then
7737
    ac_more_lines=false
7738
    rm -f conftest.s$ac_file
7739
  else
7740
    if test -z "$ac_sed_cmds"; then
7741
      ac_sed_cmds="sed -f conftest.s$ac_file"
7742
    else
7743
      ac_sed_cmds="$ac_sed_cmds | sed -f conftest.s$ac_file"
7744
    fi
7745
    ac_file=`expr $ac_file + 1`
7746
    ac_beg=$ac_end
7747
    ac_end=`expr $ac_end + $ac_max_sed_cmds`
7748
  fi
7749
done
7750
if test -z "$ac_sed_cmds"; then
7751
  ac_sed_cmds=cat
7752
fi
7753
EOF
7754
 
7755
cat >> $CONFIG_STATUS <
7756
 
7757
CONFIG_FILES=\${CONFIG_FILES-"Makefile"}
7758
EOF
7759
cat >> $CONFIG_STATUS <<\EOF
7760
for ac_file in .. $CONFIG_FILES; do if test "x$ac_file" != x..; then
7761
  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
7762
  case "$ac_file" in
7763
  *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'`
7764
       ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
7765
  *) ac_file_in="${ac_file}.in" ;;
7766
  esac
7767
 
7768
  # Adjust a relative srcdir, top_srcdir, and INSTALL for subdirectories.
7769
 
7770
  # Remove last slash and all that follows it.  Not all systems have dirname.
7771
  ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
7772
  if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
7773
    # The file is in a subdirectory.
7774
    test ! -d "$ac_dir" && mkdir "$ac_dir"
7775
    ac_dir_suffix="/`echo $ac_dir|sed 's%^\./%%'`"
7776
    # A "../" for each directory in $ac_dir_suffix.
7777
    ac_dots=`echo $ac_dir_suffix|sed 's%/[^/]*%../%g'`
7778
  else
7779
    ac_dir_suffix= ac_dots=
7780
  fi
7781
 
7782
  case "$ac_given_srcdir" in
7783
  .)  srcdir=.
7784
      if test -z "$ac_dots"; then top_srcdir=.
7785
      else top_srcdir=`echo $ac_dots|sed 's%/$%%'`; fi ;;
7786
  /*) srcdir="$ac_given_srcdir$ac_dir_suffix"; top_srcdir="$ac_given_srcdir" ;;
7787
  *) # Relative path.
7788
    srcdir="$ac_dots$ac_given_srcdir$ac_dir_suffix"
7789
    top_srcdir="$ac_dots$ac_given_srcdir" ;;
7790
  esac
7791
 
7792
  case "$ac_given_INSTALL" in
7793
  [/$]*) INSTALL="$ac_given_INSTALL" ;;
7794
  *) INSTALL="$ac_dots$ac_given_INSTALL" ;;
7795
  esac
7796
 
7797
  echo creating "$ac_file"
7798
  rm -f "$ac_file"
7799
  configure_input="Generated automatically from `echo $ac_file_in|sed 's%.*/%%'` by configure."
7800
  case "$ac_file" in
7801
  *Makefile*) ac_comsub="1i\\
7802
# $configure_input" ;;
7803
  *) ac_comsub= ;;
7804
  esac
7805
 
7806
  ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"`
7807
  sed -e "$ac_comsub
7808
s%@configure_input@%$configure_input%g
7809
s%@srcdir@%$srcdir%g
7810
s%@top_srcdir@%$top_srcdir%g
7811
s%@INSTALL@%$INSTALL%g
7812
" $ac_file_inputs | (eval "$ac_sed_cmds") > $ac_file
7813
fi; done
7814
rm -f conftest.s*
7815
 
7816
EOF
7817
cat >> $CONFIG_STATUS <
7818
 
7819
EOF
7820
cat >> $CONFIG_STATUS <<\EOF
7821
 
7822
exit 0
7823
EOF
7824
chmod +x $CONFIG_STATUS
7825
rm -fr confdefs* $ac_clean_files
7826
test "$no_create" = yes || ${CONFIG_SHELL-/bin/sh} $CONFIG_STATUS || exit 1
7827
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.