]> git.proxmox.com Git - rustc.git/blame - configure
Imported Upstream version 1.9.0+dfsg1
[rustc.git] / configure
CommitLineData
223e47cc
LB
1#!/bin/sh
2
7453a54e
SL
3# /bin/sh on Solaris is not a POSIX compatible shell, but /usr/bin/bash is.
4if [ `uname -s` = 'SunOS' -a "${POSIX_SHELL}" != "true" ]; then
5 POSIX_SHELL="true"
6 export POSIX_SHELL
7 exec /usr/bin/env bash $0 "$@"
8fi
9unset POSIX_SHELL # clear it so if we invoke other scripts, they run as bash as well
10
223e47cc 11msg() {
62682a34 12 echo "configure: $*"
223e47cc
LB
13}
14
15step_msg() {
16 msg
17 msg "$1"
18 msg
19}
20
21warn() {
22 echo "configure: WARNING: $1"
23}
24
25err() {
26 echo "configure: error: $1"
27 exit 1
28}
29
d9579d0f
AL
30run() {
31 msg "$@"
32 "$@"
33}
34
223e47cc
LB
35need_ok() {
36 if [ $? -ne 0 ]
37 then
1a4d82fc 38 err "$1"
223e47cc
LB
39 fi
40}
41
42need_cmd() {
1a4d82fc 43 if command -v $1 >/dev/null 2>&1
62682a34
SL
44 then msg "found program '$1'"
45 else err "program '$1' is missing, please install it"
223e47cc
LB
46 fi
47}
48
49make_dir() {
50 if [ ! -d $1 ]
51 then
d9579d0f 52 run mkdir -p $1
223e47cc
LB
53 fi
54}
55
56copy_if_changed() {
57 if cmp -s $1 $2
58 then
59 msg "leaving $2 unchanged"
60 else
d9579d0f 61 run cp -f $1 $2
223e47cc
LB
62 chmod u-w $2 # make copied artifact read-only
63 fi
64}
65
66move_if_changed() {
67 if cmp -s $1 $2
68 then
69 msg "leaving $2 unchanged"
70 else
d9579d0f 71 run mv -f $1 $2
223e47cc
LB
72 chmod u-w $2 # make moved artifact read-only
73 fi
74}
75
76putvar() {
77 local T
78 eval T=\$$1
79 eval TLEN=\${#$1}
80 if [ $TLEN -gt 35 ]
81 then
82 printf "configure: %-20s := %.35s ...\n" $1 "$T"
83 else
84 printf "configure: %-20s := %s %s\n" $1 "$T" "$2"
85 fi
86 printf "%-20s := %s\n" $1 "$T" >>config.tmp
87}
88
1a4d82fc
JJ
89putpathvar() {
90 local T
91 eval T=\$$1
92 eval TLEN=\${#$1}
93 if [ $TLEN -gt 35 ]
94 then
95 printf "configure: %-20s := %.35s ...\n" $1 "$T"
96 else
97 printf "configure: %-20s := %s %s\n" $1 "$T" "$2"
98 fi
99 if [ -z "$T" ]
100 then
101 printf "%-20s := \n" $1 >>config.tmp
102 else
103 printf "%-20s := \"%s\"\n" $1 "$T" >>config.tmp
104 fi
105}
106
223e47cc
LB
107probe() {
108 local V=$1
109 shift
110 local P
111 local T
112 for P
113 do
1a4d82fc 114 T=$(command -v $P 2>&1)
223e47cc
LB
115 if [ $? -eq 0 ]
116 then
d9579d0f
AL
117 VER0=$($P --version 2>/dev/null \
118 | grep -o '[vV]\?[0-9][0-9.][a-z0-9.-]*' | head -1 )
223e47cc
LB
119 if [ $? -eq 0 -a "x${VER0}" != "x" ]
120 then
121 VER="($VER0)"
122 else
123 VER=""
124 fi
125 break
126 else
127 VER=""
128 T=""
129 fi
130 done
131 eval $V=\$T
1a4d82fc 132 putpathvar $V "$VER"
223e47cc
LB
133}
134
135probe_need() {
136 local V=$1
137 probe $*
138 eval VV=\$$V
139 if [ -z "$VV" ]
140 then
141 err "needed, but unable to find any of: $*"
142 fi
143}
144
145validate_opt () {
146 for arg in $CFG_CONFIGURE_ARGS
147 do
148 isArgValid=0
149 for option in $BOOL_OPTIONS
150 do
151 if test --disable-$option = $arg
152 then
153 isArgValid=1
154 fi
155 if test --enable-$option = $arg
156 then
157 isArgValid=1
158 fi
159 done
160 for option in $VAL_OPTIONS
161 do
162 if echo "$arg" | grep -q -- "--$option="
163 then
164 isArgValid=1
165 fi
166 done
167 if [ "$arg" = "--help" ]
168 then
970d7e83 169 echo
223e47cc
LB
170 echo "No more help available for Configure options,"
171 echo "check the Wiki or join our IRC channel"
172 break
173 else
174 if test $isArgValid -eq 0
175 then
176 err "Option '$arg' is not recognized"
177 fi
178 fi
179 done
180}
181
1a4d82fc
JJ
182# `valopt OPTION_NAME DEFAULT DOC` extracts a string-valued option
183# from command line, using provided default value for the option if
184# not present, and saves it to the generated config.mk.
185#
186# `valopt_nosave` is much the same, except that it does not save the
187# result to config.mk (instead the script should use `putvar` itself
188# later on to save it). `valopt_core` is the core upon which the
189# other two are built.
190
191valopt_core() {
192 VAL_OPTIONS="$VAL_OPTIONS $2"
193
194 local SAVE=$1
195 local OP=$2
196 local DEFAULT=$3
197 shift
223e47cc
LB
198 shift
199 shift
200 local DOC="$*"
201 if [ $HELP -eq 0 ]
202 then
203 local UOP=$(echo $OP | tr '[:lower:]' '[:upper:]' | tr '\-' '\_')
204 local V="CFG_${UOP}"
9346a6ac 205 local V_PROVIDED="${V}_PROVIDED"
223e47cc
LB
206 eval $V="$DEFAULT"
207 for arg in $CFG_CONFIGURE_ARGS
208 do
209 if echo "$arg" | grep -q -- "--$OP="
210 then
211 val=$(echo "$arg" | cut -f2 -d=)
212 eval $V=$val
9346a6ac 213 eval $V_PROVIDED=1
223e47cc
LB
214 fi
215 done
1a4d82fc
JJ
216 if [ "$SAVE" = "save" ]
217 then
218 putvar $V
219 fi
223e47cc
LB
220 else
221 if [ -z "$DEFAULT" ]
222 then
223 DEFAULT="<none>"
224 fi
225 OP="${OP}=[${DEFAULT}]"
226 printf " --%-30s %s\n" "$OP" "$DOC"
227 fi
228}
229
1a4d82fc
JJ
230valopt_nosave() {
231 valopt_core nosave "$@"
232}
223e47cc 233
1a4d82fc
JJ
234valopt() {
235 valopt_core save "$@"
236}
237
238# `opt OPTION_NAME DEFAULT DOC` extracts a boolean-valued option from
239# command line, using the provided default value (0/1) for the option
240# if not present, and saves it to the generated config.mk.
241#
242# `opt_nosave` is much the same, except that it does not save the
243# result to config.mk (instead the script should use `putvar` itself
244# later on to save it). `opt_core` is the core upon which the other
245# two are built.
246
247opt_core() {
248 BOOL_OPTIONS="$BOOL_OPTIONS $2"
249
250 local SAVE=$1
251 local OP=$2
252 local DEFAULT=$3
253 shift
223e47cc
LB
254 shift
255 shift
256 local DOC="$*"
257 local FLAG=""
258
259 if [ $DEFAULT -eq 0 ]
260 then
261 FLAG="enable"
9346a6ac 262 DEFAULT_FLAG="disable"
223e47cc
LB
263 else
264 FLAG="disable"
9346a6ac 265 DEFAULT_FLAG="enable"
223e47cc
LB
266 DOC="don't $DOC"
267 fi
268
269 if [ $HELP -eq 0 ]
270 then
271 for arg in $CFG_CONFIGURE_ARGS
272 do
273 if [ "$arg" = "--${FLAG}-${OP}" ]
274 then
275 OP=$(echo $OP | tr 'a-z-' 'A-Z_')
276 FLAG=$(echo $FLAG | tr 'a-z' 'A-Z')
277 local V="CFG_${FLAG}_${OP}"
9346a6ac 278 local V_PROVIDED="CFG_${FLAG}_${OP}_PROVIDED"
223e47cc 279 eval $V=1
9346a6ac 280 eval $V_PROVIDED=1
1a4d82fc
JJ
281 if [ "$SAVE" = "save" ]
282 then
283 putvar $V
284 fi
9346a6ac
AL
285 elif [ "$arg" = "--${DEFAULT_FLAG}-${OP}" ]
286 then
287 OP=$(echo $OP | tr 'a-z-' 'A-Z_')
288 DEFAULT_FLAG=$(echo $DEFAULT_FLAG | tr 'a-z' 'A-Z')
289 local V_PROVIDED="CFG_${DEFAULT_FLAG}_${OP}_PROVIDED"
290 eval $V_PROVIDED=1
223e47cc
LB
291 fi
292 done
293 else
c1a9b12d 294 if [ -n "$META" ]
223e47cc
LB
295 then
296 OP="$OP=<$META>"
297 fi
298 printf " --%-30s %s\n" "$FLAG-$OP" "$DOC"
299 fi
300}
301
1a4d82fc
JJ
302opt_nosave() {
303 opt_core nosave "$@"
304}
305
306opt() {
307 opt_core save "$@"
308}
309
310envopt() {
311 local NAME=$1
312 local V="CFG_${NAME}"
313 eval VV=\$$V
314
315 # If configure didn't set a value already, then check environment.
316 #
317 # (It is recommended that the configure script always check the
318 # environment before setting any values to envopt variables; see
319 # e.g. how CFG_CC is handled, where it first checks `-z "$CC"`,
320 # and issues msg if it ends up employing that provided value.)
321 if [ -z "$VV" ]
322 then
323 eval $V=\$$NAME
324 eval VV=\$$V
325 fi
326
327 # If script or environment provided a value, save it.
c1a9b12d 328 if [ -n "$VV" ]
1a4d82fc
JJ
329 then
330 putvar $V
331 fi
332}
333
c1a9b12d
SL
334enable_if_not_disabled() {
335 local OP=$1
336 local UOP=$(echo $OP | tr '[:lower:]' '[:upper:]' | tr '\-' '\_')
337 local ENAB_V="CFG_ENABLE_$UOP"
338 local EXPLICITLY_DISABLED="CFG_DISABLE_${UOP}_PROVIDED"
339 eval VV=\$$EXPLICITLY_DISABLED
340 if [ -z "$VV" ]; then
341 eval $ENAB_V=1
342 fi
343}
344
1a4d82fc
JJ
345to_gnu_triple() {
346 case $1 in
347 i686-pc-windows-gnu) echo i686-w64-mingw32 ;;
348 x86_64-pc-windows-gnu) echo x86_64-w64-mingw32 ;;
349 *) echo $1 ;;
350 esac
351}
352
d9579d0f
AL
353# Prints the absolute path of a directory to stdout
354abs_path() {
355 local _path="$1"
356 # Unset CDPATH because it causes havok: it makes the destination unpredictable
357 # and triggers 'cd' to print the path to stdout. Route `cd`'s output to /dev/null
358 # for good measure.
359 (unset CDPATH && cd "$_path" > /dev/null && pwd)
360}
361
223e47cc
LB
362msg "looking for configure programs"
363need_cmd cmp
364need_cmd mkdir
365need_cmd printf
366need_cmd cut
367need_cmd head
368need_cmd grep
369need_cmd xargs
370need_cmd cp
371need_cmd find
372need_cmd uname
373need_cmd date
374need_cmd tr
375need_cmd sed
970d7e83 376need_cmd file
85aaf69f 377need_cmd make
223e47cc
LB
378
379msg "inspecting environment"
380
381CFG_OSTYPE=$(uname -s)
382CFG_CPUTYPE=$(uname -m)
383
384if [ $CFG_OSTYPE = Darwin -a $CFG_CPUTYPE = i386 ]
385then
386 # Darwin's `uname -s` lies and always returns i386. We have to use sysctl
387 # instead.
388 if sysctl hw.optional.x86_64 | grep -q ': 1'
389 then
390 CFG_CPUTYPE=x86_64
391 fi
392fi
393
394# The goal here is to come up with the same triple as LLVM would,
395# at least for the subset of platforms we're willing to target.
396
397case $CFG_OSTYPE in
398
399 Linux)
400 CFG_OSTYPE=unknown-linux-gnu
401 ;;
402
403 FreeBSD)
404 CFG_OSTYPE=unknown-freebsd
405 ;;
406
1a4d82fc
JJ
407 DragonFly)
408 CFG_OSTYPE=unknown-dragonfly
409 ;;
410
c34b1796
AL
411 Bitrig)
412 CFG_OSTYPE=unknown-bitrig
413 ;;
414
85aaf69f 415 OpenBSD)
c34b1796 416 CFG_OSTYPE=unknown-openbsd
85aaf69f
SL
417 ;;
418
c1a9b12d
SL
419 NetBSD)
420 CFG_OSTYPE=unknown-netbsd
421 ;;
422
223e47cc
LB
423 Darwin)
424 CFG_OSTYPE=apple-darwin
425 ;;
426
7453a54e
SL
427 SunOS)
428 CFG_OSTYPE=sun-solaris
429 CFG_CPUTYPE=$(isainfo -n)
430 ;;
431
1a4d82fc
JJ
432 MINGW*)
433 # msys' `uname` does not print gcc configuration, but prints msys
434 # configuration. so we cannot believe `uname -m`:
435 # msys1 is always i686 and msys2 is always x86_64.
436 # instead, msys defines $MSYSTEM which is MINGW32 on i686 and
437 # MINGW64 on x86_64.
438 CFG_CPUTYPE=i686
439 CFG_OSTYPE=pc-windows-gnu
440 if [ "$MSYSTEM" = MINGW64 ]
441 then
442 CFG_CPUTYPE=x86_64
443 fi
223e47cc 444 ;;
1a4d82fc
JJ
445
446 MSYS*)
447 CFG_OSTYPE=pc-windows-gnu
448 ;;
449
c34b1796 450# Thad's Cygwin identifiers below
223e47cc
LB
451
452# Vista 32 bit
453 CYGWIN_NT-6.0)
1a4d82fc 454 CFG_OSTYPE=pc-windows-gnu
223e47cc
LB
455 CFG_CPUTYPE=i686
456 ;;
457
458# Vista 64 bit
459 CYGWIN_NT-6.0-WOW64)
1a4d82fc 460 CFG_OSTYPE=pc-windows-gnu
223e47cc
LB
461 CFG_CPUTYPE=x86_64
462 ;;
463
464# Win 7 32 bit
465 CYGWIN_NT-6.1)
1a4d82fc 466 CFG_OSTYPE=pc-windows-gnu
223e47cc
LB
467 CFG_CPUTYPE=i686
468 ;;
469
470# Win 7 64 bit
471 CYGWIN_NT-6.1-WOW64)
1a4d82fc 472 CFG_OSTYPE=pc-windows-gnu
223e47cc
LB
473 CFG_CPUTYPE=x86_64
474 ;;
475
c34b1796
AL
476# Win 8 # uname -s on 64-bit cygwin does not contain WOW64, so simply use uname -m to detect arch (works in my install)
477 CYGWIN_NT-6.3)
478 CFG_OSTYPE=pc-windows-gnu
479 ;;
223e47cc
LB
480# We do not detect other OS such as XP/2003 using 64 bit using uname.
481# If we want to in the future, we will need to use Cygwin - Chuck's csih helper in /usr/lib/csih/winProductName.exe or alternative.
482 *)
483 err "unknown OS type: $CFG_OSTYPE"
484 ;;
485esac
486
487
488case $CFG_CPUTYPE in
489
490 i386 | i486 | i686 | i786 | x86)
491 CFG_CPUTYPE=i686
492 ;;
493
494 xscale | arm)
495 CFG_CPUTYPE=arm
496 ;;
497
1a4d82fc
JJ
498 armv7l)
499 CFG_CPUTYPE=arm
500 CFG_OSTYPE="${CFG_OSTYPE}eabihf"
501 ;;
502
503 aarch64)
504 CFG_CPUTYPE=aarch64
505 ;;
506
9cc50fc6 507 powerpc | ppc)
85aaf69f
SL
508 CFG_CPUTYPE=powerpc
509 ;;
510
9cc50fc6
SL
511 powerpc64 | ppc64)
512 CFG_CPUTYPE=powerpc64
513 ;;
514
515 powerpc64le | ppc64le)
516 CFG_CPUTYPE=powerpc64le
517 ;;
518
223e47cc
LB
519 x86_64 | x86-64 | x64 | amd64)
520 CFG_CPUTYPE=x86_64
521 ;;
522
523 *)
524 err "unknown CPU type: $CFG_CPUTYPE"
525esac
526
527# Detect 64 bit linux systems with 32 bit userland and force 32 bit compilation
528if [ $CFG_OSTYPE = unknown-linux-gnu -a $CFG_CPUTYPE = x86_64 ]
529then
c34b1796
AL
530 # $SHELL does not exist in standard 'sh', so probably only exists
531 # if configure is running in an interactive bash shell. /usr/bin/env
532 # exists *everywhere*.
533 BIN_TO_PROBE="$SHELL"
9cc50fc6
SL
534 if [ ! -r "$BIN_TO_PROBE" ]; then
535 if [ -r "/usr/bin/env" ]; then
536 BIN_TO_PROBE="/usr/bin/env"
537 else
538 warn "Cannot check if the userland is i686 or x86_64"
539 fi
540 fi
541 file -L "$BIN_TO_PROBE" | grep -q "x86[_-]64"
542 if [ $? != 0 ]; then
543 msg "i686 userland on x86_64 Linux kernel"
544 CFG_CPUTYPE=i686
223e47cc
LB
545 fi
546fi
547
548
1a4d82fc 549DEFAULT_BUILD="${CFG_CPUTYPE}-${CFG_OSTYPE}"
223e47cc 550
d9579d0f 551CFG_SRC_DIR="$(abs_path $(dirname $0))/"
62682a34 552CFG_SRC_DIR_RELATIVE="$(dirname $0)/"
223e47cc 553CFG_BUILD_DIR="$(pwd)/"
1a4d82fc 554CFG_SELF="$0"
223e47cc
LB
555CFG_CONFIGURE_ARGS="$@"
556
92a42be0 557
7453a54e 558case "${CFG_SRC_DIR}" in
92a42be0
SL
559 *\ * )
560 err "The path to the rust source directory contains spaces, which is not supported"
561 ;;
562 *)
563 ;;
564esac
565
566
223e47cc
LB
567OPTIONS=""
568HELP=0
569if [ "$1" = "--help" ]
570then
571 HELP=1
572 shift
970d7e83 573 echo
223e47cc 574 echo "Usage: $CFG_SELF [options]"
970d7e83 575 echo
223e47cc 576 echo "Options:"
970d7e83 577 echo
223e47cc
LB
578else
579 msg "recreating config.tmp"
580 echo '' >config.tmp
581
582 step_msg "processing $CFG_SELF args"
583fi
584
585BOOL_OPTIONS=""
586VAL_OPTIONS=""
587
d9579d0f 588opt debug 0 "debug mode; disables optimization unless \`--enable-optimize\` given"
223e47cc
LB
589opt valgrind 0 "run tests with valgrind (memcheck by default)"
590opt helgrind 0 "run tests with helgrind instead of memcheck"
1a4d82fc 591opt valgrind-rpass 1 "run rpass-valgrind tests with valgrind"
c34b1796
AL
592opt docs 1 "build standard library documentation"
593opt compiler-docs 0 "build compiler documentation"
1a4d82fc 594opt optimize-tests 1 "build tests with optimizations"
d9579d0f 595opt debuginfo-tests 0 "build tests with debugger metadata"
1a4d82fc 596opt libcpp 1 "build with llvm with libc++ instead of libstdc++ when using clang"
9346a6ac
AL
597opt llvm-assertions 0 "build LLVM with assertions"
598opt debug-assertions 0 "build with debugging assertions"
223e47cc 599opt fast-make 0 "use .gitmodules as timestamp for submodule deps"
970d7e83 600opt ccache 0 "invoke gcc/clang via ccache to reuse object files between builds"
223e47cc 601opt local-rust 0 "use an installed rustc rather than downloading a snapshot"
1a4d82fc 602opt llvm-static-stdcpp 0 "statically link to libstdc++ for LLVM"
9cc50fc6 603opt rpath 1 "build rpaths into rustc itself"
b039eaaf 604opt stage0-landing-pads 1 "enable landing pads during bootstrap with stage0"
1a4d82fc
JJ
605# This is used by the automation to produce single-target nightlies
606opt dist-host-only 0 "only install bins for the host architecture"
607opt inject-std-version 1 "inject the current compiler version of libstd into programs"
62682a34 608opt llvm-version-check 1 "check if the LLVM version is supported, build anyway"
7453a54e 609opt rustbuild 0 "use the rust and cargo based build system"
54a0048b
SL
610opt orbit 0 "get MIR where it belongs - everywhere; most importantly, in orbit"
611opt codegen-tests 1 "run the src/test/codegen tests"
1a4d82fc 612
9346a6ac
AL
613# Optimization and debugging options. These may be overridden by the release channel, etc.
614opt_nosave optimize 1 "build optimized rust code"
615opt_nosave optimize-cxx 1 "build optimized C++ code"
616opt_nosave optimize-llvm 1 "build optimized LLVM"
617opt_nosave llvm-assertions 0 "build LLVM with assertions"
618opt_nosave debug-assertions 0 "build with debugging assertions"
619opt_nosave debuginfo 0 "build with debugger metadata"
620opt_nosave debug-jemalloc 0 "build jemalloc with --enable-debug --enable-fill"
621
1a4d82fc
JJ
622valopt localstatedir "/var/lib" "local state directory"
623valopt sysconfdir "/etc" "install system configuration files"
624
625valopt datadir "${CFG_PREFIX}/share" "install data"
626valopt infodir "${CFG_PREFIX}/share/info" "install additional info"
223e47cc 627valopt llvm-root "" "set LLVM root"
62682a34 628valopt python "" "set path to python"
1a4d82fc
JJ
629valopt jemalloc-root "" "set directory where libjemalloc_pic.a is located"
630valopt build "${DEFAULT_BUILD}" "GNUs ./configure syntax LLVM build triple"
7453a54e 631valopt android-cross-path "" "Android NDK standalone path (deprecated)"
e9174d1e 632valopt i686-linux-android-ndk "" "i686-linux-android NDK standalone path"
c1a9b12d
SL
633valopt arm-linux-androideabi-ndk "" "arm-linux-androideabi NDK standalone path"
634valopt aarch64-linux-android-ndk "" "aarch64-linux-android NDK standalone path"
9cc50fc6 635valopt nacl-cross-path "" "NaCl SDK path (Pepper Canary is recommended). Must be absolute!"
9346a6ac 636valopt release-channel "dev" "the name of the release channel to build"
d9579d0f 637valopt musl-root "/usr/local" "MUSL root installation directory"
9cc50fc6 638valopt extra-filename "" "Additional data that is hashed and passed to the -C extra-filename flag"
223e47cc 639
e9174d1e
SL
640# Used on systems where "cc" and "ar" are unavailable
641valopt default-linker "cc" "the default linker"
642valopt default-ar "ar" "the default ar"
643
1a4d82fc
JJ
644# Many of these are saved below during the "writing configuration" step
645# (others are conditionally saved).
646opt_nosave manage-submodules 1 "let the build manage the git submodules"
647opt_nosave clang 0 "prefer clang to gcc for building the runtime"
9346a6ac 648opt_nosave jemalloc 1 "build liballoc with jemalloc"
d9579d0f 649opt elf-tls 1 "elf thread local storage on platforms where supported"
1a4d82fc
JJ
650
651valopt_nosave prefix "/usr/local" "set installation prefix"
652valopt_nosave local-rust-root "/usr/local" "set prefix for local rust binary"
653valopt_nosave host "${CFG_BUILD}" "GNUs ./configure syntax LLVM host triples"
654valopt_nosave target "${CFG_HOST}" "GNUs ./configure syntax LLVM target triples"
655valopt_nosave mandir "${CFG_PREFIX}/share/man" "install man pages in PATH"
1a4d82fc 656
92a42be0
SL
657# On Windows this determines root of the subtree for target libraries.
658# Host runtime libs always go to 'bin'.
659valopt libdir "${CFG_PREFIX}/lib" "install libraries"
1a4d82fc
JJ
660
661case "$CFG_LIBDIR" in
662 "$CFG_PREFIX"/*) CAT_INC=2;;
663 "$CFG_PREFIX"*) CAT_INC=1;;
664 *)
665 err "libdir must begin with the prefix. Use --prefix to set it accordingly.";;
666esac
667
668CFG_LIBDIR_RELATIVE=`echo ${CFG_LIBDIR} | cut -c$((${#CFG_PREFIX}+${CAT_INC}))-`
669
223e47cc
LB
670if [ $HELP -eq 1 ]
671then
970d7e83 672 echo
223e47cc
LB
673 exit 0
674fi
675
1a4d82fc
JJ
676# Validate Options
677step_msg "validating $CFG_SELF args"
678validate_opt
679
9346a6ac 680# Validate the release channel, and configure options
1a4d82fc 681case "$CFG_RELEASE_CHANNEL" in
9346a6ac
AL
682 nightly )
683 msg "overriding settings for $CFG_RELEASE_CHANNEL"
684 CFG_ENABLE_LLVM_ASSERTIONS=1
1a4d82fc 685 ;;
9346a6ac
AL
686 dev | beta | stable)
687 ;;
688 *)
1a4d82fc
JJ
689 err "release channel must be 'dev', 'nightly', 'beta' or 'stable'"
690 ;;
691esac
692
9346a6ac
AL
693# Adjust perf and debug options for debug mode
694if [ -n "$CFG_ENABLE_DEBUG" ]; then
695 msg "debug mode enabled, setting performance options"
696 if [ -z "$CFG_ENABLE_OPTIMIZE_PROVIDED" ]; then
697 msg "optimization not explicitly enabled, disabling optimization"
698 CFG_DISABLE_OPTIMIZE=1
699 CFG_DISABLE_OPTIMIZE_CXX=1
700 fi
c1a9b12d
SL
701
702 # Set following variables to 1 unless setting already provided
703 enable_if_not_disabled debug-assertions
704 enable_if_not_disabled debug-jemalloc
705 enable_if_not_disabled debuginfo
706 enable_if_not_disabled llvm-assertions
1a4d82fc 707fi
9346a6ac
AL
708
709# OK, now write the debugging options
710if [ -n "$CFG_DISABLE_OPTIMIZE" ]; then putvar CFG_DISABLE_OPTIMIZE; fi
711if [ -n "$CFG_DISABLE_OPTIMIZE_CXX" ]; then putvar CFG_DISABLE_OPTIMIZE_CXX; fi
712if [ -n "$CFG_DISABLE_OPTIMIZE_LLVM" ]; then putvar CFG_DISABLE_OPTIMIZE_LLVM; fi
713if [ -n "$CFG_ENABLE_LLVM_ASSERTIONS" ]; then putvar CFG_ENABLE_LLVM_ASSERTIONS; fi
714if [ -n "$CFG_ENABLE_DEBUG_ASSERTIONS" ]; then putvar CFG_ENABLE_DEBUG_ASSERTIONS; fi
715if [ -n "$CFG_ENABLE_DEBUGINFO" ]; then putvar CFG_ENABLE_DEBUGINFO; fi
716if [ -n "$CFG_ENABLE_DEBUG_JEMALLOC" ]; then putvar CFG_ENABLE_DEBUG_JEMALLOC; fi
1a4d82fc 717
54a0048b 718if [ -n "$CFG_ENABLE_ORBIT" ]; then putvar CFG_ENABLE_ORBIT; fi
223e47cc
LB
719
720step_msg "looking for build programs"
721
1a4d82fc 722probe_need CFG_CURLORWGET curl wget
62682a34 723if [ -z "$CFG_PYTHON_PROVIDED" ]; then
7453a54e 724 probe_need CFG_PYTHON python2.7 python2 python
62682a34 725fi
223e47cc
LB
726
727python_version=$($CFG_PYTHON -V 2>&1)
7453a54e
SL
728if [ $(echo $python_version | grep -c '^Python 2\.7') -ne 1 ]; then
729 err "Found $python_version, but Python 2.7 is required"
223e47cc
LB
730fi
731
732# If we have no git directory then we are probably a tarball distribution
733# and shouldn't attempt to load submodules
734if [ ! -e ${CFG_SRC_DIR}.git ]
735then
736 probe CFG_GIT git
737 msg "git: no git directory. disabling submodules"
738 CFG_DISABLE_MANAGE_SUBMODULES=1
739else
740 probe_need CFG_GIT git
741fi
742
d9579d0f
AL
743# Use `md5sum` on GNU platforms, or `md5 -q` on BSD
744probe CFG_MD5 md5
745probe CFG_MD5SUM md5sum
746if [ -n "$CFG_MD5" ]
747then
62682a34 748 CFG_HASH_COMMAND="$CFG_MD5 -q | cut -c 1-8"
d9579d0f
AL
749elif [ -n "$CFG_MD5SUM" ]
750then
62682a34 751 CFG_HASH_COMMAND="$CFG_MD5SUM | cut -c 1-8"
d9579d0f
AL
752else
753 err 'could not find one of: md5 md5sum'
754fi
755putvar CFG_HASH_COMMAND
756
223e47cc 757probe CFG_CLANG clang++
970d7e83 758probe CFG_CCACHE ccache
223e47cc
LB
759probe CFG_GCC gcc
760probe CFG_LD ld
761probe CFG_VALGRIND valgrind
762probe CFG_PERF perf
763probe CFG_ISCC iscc
1a4d82fc
JJ
764probe CFG_ANTLR4 antlr4
765probe CFG_GRUN grun
85aaf69f
SL
766probe CFG_FLEX flex
767probe CFG_BISON bison
223e47cc 768probe CFG_GDB gdb
1a4d82fc
JJ
769probe CFG_LLDB lldb
770
9346a6ac
AL
771# On MacOS X, invoking `javac` pops up a dialog if the JDK is not
772# installed. Since `javac` is only used if `antlr4` is available,
773# probe for it only in this case.
c1a9b12d 774if [ -n "$CFG_ANTLR4" ]
9346a6ac
AL
775then
776 probe CFG_JAVAC javac
777fi
778
d9579d0f
AL
779# the valgrind rpass tests will fail if you don't have a valgrind, but they're
780# only disabled if you opt out.
781if [ -z "$CFG_VALGRIND" ]
782then
783 # If the user has explicitly asked for valgrind tests, then fail
784 if [ -n "$CFG_ENABLE_VALGRIND" ] && [ -n "$CFG_ENABLE_VALGRIND_PROVIDED" ]
785 then
786 err "No valgrind present, but valgrind tests explicitly requested"
787 else
788 CFG_DISABLE_VALGRIND_RPASS=1
789 putvar CFG_DISABLE_VALGRIND_RPASS
790 fi
791fi
792
c1a9b12d 793if [ -n "$CFG_GDB" ]
223e47cc 794then
1a4d82fc
JJ
795 # Store GDB's version
796 CFG_GDB_VERSION=$($CFG_GDB --version 2>/dev/null | head -1)
797 putvar CFG_GDB_VERSION
798fi
799
c1a9b12d 800if [ -n "$CFG_LLDB" ]
1a4d82fc
JJ
801then
802 # Store LLDB's version
803 CFG_LLDB_VERSION=$($CFG_LLDB --version 2>/dev/null | head -1)
804 putvar CFG_LLDB_VERSION
805
806 # If CFG_LLDB_PYTHON_DIR is not already set from the outside and valid, try to read it from
807 # LLDB via the -P commandline options.
808 if [ -z "$CFG_LLDB_PYTHON_DIR" ] || [ ! -d "$CFG_LLDB_PYTHON_DIR" ]
809 then
810 CFG_LLDB_PYTHON_DIR=$($CFG_LLDB -P)
811
812 # If CFG_LLDB_PYTHON_DIR is not a valid directory, set it to something more readable
813 if [ ! -d "$CFG_LLDB_PYTHON_DIR" ]
814 then
815 CFG_LLDB_PYTHON_DIR="LLDB_PYTHON_DIRECTORY_NOT_FOUND"
816 fi
817
818 putvar CFG_LLDB_PYTHON_DIR
819 fi
223e47cc
LB
820fi
821
970d7e83
LB
822step_msg "looking for target specific programs"
823
824probe CFG_ADB adb
825
1a4d82fc 826BIN_SUF=
62682a34 827if [ "$CFG_OSTYPE" = "pc-windows-gnu" ] || [ "$CFG_OSTYPE" = "pc-windows-msvc" ]
223e47cc 828then
1a4d82fc 829 BIN_SUF=.exe
223e47cc
LB
830fi
831
c1a9b12d 832if [ -n "$CFG_ENABLE_LOCAL_RUST" ]
223e47cc 833then
1a4d82fc
JJ
834 system_rustc=$(which rustc)
835 if [ -f ${CFG_LOCAL_RUST_ROOT}/bin/rustc${BIN_SUF} ]
223e47cc 836 then
1a4d82fc
JJ
837 : # everything already configured
838 elif [ -n "$system_rustc" ]
839 then
840 # we assume that rustc is in a /bin directory
841 CFG_LOCAL_RUST_ROOT=${system_rustc%/bin/rustc}
223e47cc 842 else
1a4d82fc 843 err "no local rust to use"
223e47cc 844 fi
1a4d82fc
JJ
845
846 CMD="${CFG_LOCAL_RUST_ROOT}/bin/rustc${BIN_SUF}"
847 LRV=`$CMD --version`
848 if [ $? -ne 0 ]
849 then
850 step_msg "failure while running $CMD --version"
851 exit 1
852 fi
853 step_msg "using rustc at: ${CFG_LOCAL_RUST_ROOT} with version: $LRV"
854 putvar CFG_LOCAL_RUST_ROOT
223e47cc
LB
855fi
856
c34b1796
AL
857# Force bitrig to build with clang; gcc doesn't like us there
858if [ $CFG_OSTYPE = unknown-bitrig ]
859then
7453a54e 860 step_msg "on Bitrig, forcing use of clang"
c34b1796 861 CFG_ENABLE_CLANG=1
c34b1796
AL
862fi
863
e9174d1e
SL
864# default gcc version under OpenBSD maybe too old, try using egcc, which is a
865# gcc version from ports
866if [ $CFG_OSTYPE = unknown-openbsd ]
867then
868 if [ $("$CFG_GCC" --version 2>&1 | grep -c ' 4\.[0-6]') -ne 0 ]; then
869 step_msg "older GCC found, try with egcc instead"
870
871 # probe again but using egcc
872 probe CFG_GCC egcc
873
874 # and use egcc/eg++ for CC/CXX too if it was found
875 # (but user setting has priority)
876 if [ -n "$CFG_GCC" ]; then
877 CC="${CC:-egcc}"
878 CXX="${CXX:-eg++}"
879 fi
880 fi
e9174d1e
SL
881fi
882
1a4d82fc
JJ
883# OS X 10.9, gcc is actually clang. This can cause some confusion in the build
884# system, so if we find that gcc is clang, we should just use clang directly.
885if [ $CFG_OSTYPE = apple-darwin -a -z "$CFG_ENABLE_CLANG" ]
886then
887 CFG_OSX_GCC_VERSION=$("$CFG_GCC" --version 2>&1 | grep "Apple LLVM version")
888 if [ $? -eq 0 ]
889 then
d9579d0f 890 step_msg "on OS X >=10.9, forcing use of clang"
1a4d82fc
JJ
891 CFG_ENABLE_CLANG=1
892 else
893 if [ $("$CFG_GCC" --version 2>&1 | grep -c ' 4\.[0-6]') -ne 0 ]; then
894 step_msg "older GCC found, using clang instead"
895 CFG_ENABLE_CLANG=1
896 else
897 # on OS X, with xcode 5 and newer, certain developers may have
898 # cc, gcc and g++ point to a mixture of clang and gcc
899 # if so, this will create very strange build errors
900 # this last stanza is to detect some such problems and save the future rust
901 # contributor some time solving that issue.
902 # this detection could be generalized to other OSes aside from OS X
903 # but the issue seems most likely to happen on OS X
904
905 chk_cc () {
906 $1 --version 2> /dev/null | grep -q $2
907 }
908 # check that gcc, cc and g++ all point to the same compiler.
909 # note that for xcode 5, g++ points to clang, not clang++
910 if !((chk_cc gcc clang && chk_cc g++ clang) ||
911 (chk_cc gcc gcc &&( chk_cc g++ g++ || chk g++ gcc))); then
912 err "the gcc and g++ in your path point to different compilers.
913 Check which versions are in your path with gcc --version and g++ --version.
914 To resolve this problem, either fix your PATH or run configure with --enable-clang"
915 fi
916
917 fi
918 fi
919fi
920
c1a9b12d
SL
921# If the clang isn't already enabled, check for GCC, and if it is missing, turn
922# on clang as a backup.
923if [ -z "$CFG_ENABLE_CLANG" ]
924then
925 CFG_GCC_VERSION=$("$CFG_GCC" --version 2>&1)
926 if [ $? -ne 0 ]
927 then
928 step_msg "GCC not installed, will try using Clang"
929 CFG_ENABLE_CLANG=1
930 fi
931fi
932
1a4d82fc
JJ
933# Okay, at this point, we have made up our minds about whether we are
934# going to force CFG_ENABLE_CLANG or not; save the setting if so.
c1a9b12d 935if [ -n "$CFG_ENABLE_CLANG" ]
1a4d82fc
JJ
936then
937 putvar CFG_ENABLE_CLANG
938fi
939
9cc50fc6
SL
940if [ -z "$CFG_DISABLE_LIBCPP" -a -n "$CFG_ENABLE_CLANG" ]
941then
942 CFG_USING_LIBCPP="1"
943else
944 CFG_USING_LIBCPP="0"
945fi
946
9346a6ac 947# Same with jemalloc. save the setting here.
c1a9b12d 948if [ -n "$CFG_DISABLE_JEMALLOC" ]
9346a6ac
AL
949then
950 putvar CFG_DISABLE_JEMALLOC
951fi
952
c1a9b12d 953if [ -n "$CFG_LLVM_ROOT" -a -z "$CFG_DISABLE_LLVM_VERSION_CHECK" -a -e "$CFG_LLVM_ROOT/bin/llvm-config" ]
223e47cc
LB
954then
955 step_msg "using custom LLVM at $CFG_LLVM_ROOT"
956
957 LLVM_CONFIG="$CFG_LLVM_ROOT/bin/llvm-config"
958 LLVM_VERSION=$($LLVM_CONFIG --version)
959
960 case $LLVM_VERSION in
54a0048b 961 (3.[6-8]*)
1a4d82fc
JJ
962 msg "found ok version of LLVM: $LLVM_VERSION"
963 ;;
964 (*)
54a0048b 965 err "bad LLVM version: $LLVM_VERSION, need >=3.6"
1a4d82fc 966 ;;
223e47cc
LB
967 esac
968fi
969
1a4d82fc
JJ
970# Even when the user overrides the choice of CC, still try to detect
971# clang to disable some clang-specific warnings. We here draw a
972# distinction between:
973#
974# CFG_ENABLE_CLANG : passed --enable-clang, or host "requires" clang,
975# CFG_USING_CLANG : compiler (clang / gcc / $CC) looks like clang.
976#
977# This distinction is important because there are some safeguards we
978# would prefer to skip when merely CFG_USING_CLANG is set; but when
979# CFG_ENABLE_CLANG is set, that indicates that we are opting into
980# running such safeguards.
981
c1a9b12d 982if [ -n "$CC" ]
223e47cc 983then
1a4d82fc
JJ
984 msg "skipping compiler inference steps; using provided CC=$CC"
985 CFG_CC="$CC"
986
987 CFG_OSX_CC_VERSION=$("$CFG_CC" --version 2>&1 | grep "clang")
988 if [ $? -eq 0 ]
223e47cc 989 then
1a4d82fc
JJ
990 step_msg "note, user-provided CC looks like clang; CC=$CC."
991 CFG_USING_CLANG=1
992 putvar CFG_USING_CLANG
223e47cc 993 fi
223e47cc 994else
c1a9b12d 995 if [ -n "$CFG_ENABLE_CLANG" ]
1a4d82fc
JJ
996 then
997 if [ -z "$CFG_CLANG" ]
998 then
999 err "clang requested but not found"
1000 fi
1001 CFG_CC="$CFG_CLANG"
1002 CFG_USING_CLANG=1
1003 putvar CFG_USING_CLANG
1004 else
1005 CFG_CC="gcc"
1006 fi
1007fi
1008
c1a9b12d 1009if [ -n "$CFG_ENABLE_CLANG" ]
1a4d82fc 1010then
62682a34
SL
1011 case "$CC" in
1012 (''|*clang)
1013 CFG_CLANG_REPORTED_VERSION=$($CFG_CC --version | grep version)
1014
c1a9b12d 1015 if echo $CFG_CLANG_REPORTED_VERSION | grep -q "(based on LLVM "; then
62682a34 1016 CFG_CLANG_VERSION=$(echo $CFG_CLANG_REPORTED_VERSION | sed 's/.*(based on LLVM \(.*\))/\1/')
c1a9b12d 1017 elif echo $CFG_CLANG_REPORTED_VERSION | grep -q "Apple LLVM"; then
62682a34
SL
1018 CFG_OSX_CLANG_VERSION=$(echo $CFG_CLANG_REPORTED_VERSION | sed 's/.*version \(.*\) .*/\1/')
1019 else
1020 CFG_CLANG_VERSION=$(echo $CFG_CLANG_REPORTED_VERSION | sed 's/.*version \(.*\) .*/\1/')
1021 fi
1022
c1a9b12d 1023 if [ -n "$CFG_OSX_CLANG_VERSION" ]
62682a34
SL
1024 then
1025 case $CFG_OSX_CLANG_VERSION in
54a0048b 1026 (7.0* | 7.1* | 7.2* | 7.3*)
62682a34
SL
1027 step_msg "found ok version of APPLE CLANG: $CFG_OSX_CLANG_VERSION"
1028 ;;
1029 (*)
1030 err "bad APPLE CLANG version: $CFG_OSX_CLANG_VERSION, need >=7.0"
1031 ;;
1032 esac
1033 else
1034 case $CFG_CLANG_VERSION in
7453a54e 1035 (3.2* | 3.3* | 3.4* | 3.5* | 3.6* | 3.7* | 3.8* | 3.9*)
62682a34
SL
1036 step_msg "found ok version of CLANG: $CFG_CLANG_VERSION"
1037 ;;
1038 (*)
1039 err "bad CLANG version: $CFG_CLANG_VERSION, need >=3.0svn"
1040 ;;
1041 esac
1042 fi
1043
1044 if [ -z "$CC" ]
1045 then
1046 CFG_CC="clang"
1047 CFG_CXX="clang++"
1048 fi
1049 esac
223e47cc
LB
1050fi
1051
c1a9b12d 1052if [ -n "$CFG_ENABLE_CCACHE" ]
970d7e83 1053then
c1a9b12d 1054 if [ -z "$CFG_CCACHE" ]
970d7e83 1055 then
c1a9b12d 1056 err "ccache requested but not found"
970d7e83 1057 fi
c1a9b12d
SL
1058
1059 CFG_CC="ccache $CFG_CC"
1a4d82fc 1060fi
970d7e83 1061
1a4d82fc
JJ
1062if [ -z "$CC" -a -z "$CFG_ENABLE_CLANG" -a -z "$CFG_GCC" ]
1063then
1064 err "either clang or gcc is required"
970d7e83
LB
1065fi
1066
1a4d82fc
JJ
1067# All safeguards based on $CFG_ENABLE_CLANG should occur before this
1068# point in the script; after this point, script logic should inspect
1069# $CFG_USING_CLANG rather than $CFG_ENABLE_CLANG.
1070
92a42be0 1071# Set CFG_{CC,CXX,CPP,CFLAGS,CXXFLAGS,LDFLAGS}
1a4d82fc
JJ
1072envopt CC
1073envopt CXX
1074envopt CPP
1075envopt CFLAGS
1076envopt CXXFLAGS
92a42be0 1077envopt LDFLAGS
223e47cc 1078
b039eaaf
SL
1079# stdc++ name in use
1080# used to manage non-standard name (on OpenBSD for example)
1081program_transform_name=$($CFG_CC -v 2>&1 | sed -n "s/.*--program-transform-name='\([^']*\)'.*/\1/p")
1082CFG_STDCPP_NAME=$(echo "stdc++" | sed "${program_transform_name}")
1083putvar CFG_STDCPP_NAME
1084
1a4d82fc 1085# a little post-processing of various config values
223e47cc 1086CFG_PREFIX=${CFG_PREFIX%/}
1a4d82fc
JJ
1087CFG_MANDIR=${CFG_MANDIR%/}
1088CFG_HOST="$(echo $CFG_HOST | tr ',' ' ')"
1089CFG_TARGET="$(echo $CFG_TARGET | tr ',' ' ')"
1090CFG_SUPPORTED_TARGET=""
1091for target_file in ${CFG_SRC_DIR}mk/cfg/*.mk; do
1092 CFG_SUPPORTED_TARGET="${CFG_SUPPORTED_TARGET} $(basename "$target_file" .mk)"
1093done
223e47cc 1094
c1a9b12d
SL
1095# copy build-triples to host-triples so that builds are a subset of hosts
1096V_TEMP=""
1097for i in $CFG_BUILD $CFG_HOST;
1098do
1099 echo "$V_TEMP" | grep -qF $i || V_TEMP="$V_TEMP${V_TEMP:+ }$i"
1100done
1101CFG_HOST=$V_TEMP
1102
223e47cc
LB
1103# copy host-triples to target-triples so that hosts are a subset of targets
1104V_TEMP=""
1a4d82fc 1105for i in $CFG_HOST $CFG_TARGET;
223e47cc
LB
1106do
1107 echo "$V_TEMP" | grep -qF $i || V_TEMP="$V_TEMP${V_TEMP:+ }$i"
1108done
1a4d82fc 1109CFG_TARGET=$V_TEMP
223e47cc
LB
1110
1111# check target-specific tool-chains
1a4d82fc 1112for i in $CFG_TARGET
223e47cc
LB
1113do
1114 L_CHECK=false
1a4d82fc 1115 for j in $CFG_SUPPORTED_TARGET
223e47cc
LB
1116 do
1117 if [ $i = $j ]
1118 then
1119 L_CHECK=true
1120 fi
1121 done
1122
1123 if [ $L_CHECK = false ]
1124 then
1125 err "unsupported target triples \"$i\" found"
1126 fi
1127
1128 case $i in
c1a9b12d
SL
1129 *android*)
1130 upper_snake_target=$(echo "$i" | tr '[:lower:]' '[:upper:]' | tr '\-' '\_')
1131 eval ndk=\$"CFG_${upper_snake_target}_NDK"
1132 if [ -z "$ndk" ]
223e47cc 1133 then
c1a9b12d
SL
1134 ndk=$CFG_ANDROID_CROSS_PATH
1135 eval "CFG_${upper_snake_target}_NDK"=$CFG_ANDROID_CROSS_PATH
1136 warn "generic/default Android NDK option is deprecated (use --$i-ndk option instead)"
223e47cc 1137 fi
c1a9b12d
SL
1138
1139 # Perform a basic sanity check of the NDK
1140 for android_ndk_tool in "$ndk/bin/$i-gcc" "$ndk/bin/$i-g++" "$ndk/bin/$i-ar"
1141 do
1142 if [ ! -f $android_ndk_tool ]
1143 then
1144 err "NDK tool $android_ndk_tool not found (bad or missing --$i-ndk option?)"
1145 fi
1146 done
223e47cc 1147 ;;
9cc50fc6
SL
1148 *-unknown-nacl)
1149 if [ -z "$CFG_NACL_CROSS_PATH" ]
1150 then
1151 err "I need the NaCl SDK path! (use --nacl-cross-path)"
1152 fi
1153 ;;
1a4d82fc
JJ
1154 arm-apple-darwin)
1155 if [ $CFG_OSTYPE != apple-darwin ]
1156 then
1157 err "The iOS target is only supported on Mac OS X"
1158 fi
1159 ;;
1160
d9579d0f 1161
7453a54e 1162 x86_64-*-musl)
d9579d0f
AL
1163 if [ ! -f $CFG_MUSL_ROOT/lib/libc.a ]
1164 then
1165 err "musl libc $CFG_MUSL_ROOT/lib/libc.a not found"
1166 fi
1167 ;;
62682a34 1168
c1a9b12d 1169 *-msvc)
62682a34
SL
1170 # There are some MSYS python builds which will auto-translate
1171 # windows-style paths to MSYS-style paths in Python itself.
1172 # Unfortunately this breaks LLVM's build system as somewhere along
1173 # the line LLVM prints a path into a file from Python and then CMake
1174 # later tries to interpret that path. If Python prints a MSYS path
1175 # and CMake tries to use it as a Windows path, you're gonna have a
1176 # Bad Time.
1177 #
1178 # Consequently here we try to detect when that happens and print an
1179 # error if it does.
e9174d1e 1180 if $CFG_PYTHON -c 'import sys; print sys.argv[1]' `pwd` | grep '^/' > /dev/null
62682a34 1181 then
e9174d1e
SL
1182 err "
1183
1184python is silently translating windows paths to MSYS paths \
1185and the build will fail if this python is used.
1186
1187Either an official python install must be used or an \
1188alternative python package in MinGW must be used.
1189
1190If you are building under msys2 try installing the mingw-w64-x86_64-python2 \
1191package instead of python2:
1192
1193$ pacman -R python2 && pacman -S mingw-w64-x86_64-python2
1194"
62682a34
SL
1195 fi
1196
1197 # MSVC requires cmake because that's how we're going to build LLVM
1198 probe_need CFG_CMAKE cmake
1199
e9174d1e
SL
1200 # There are three builds of cmake on windows: MSVC, MinGW and Cygwin
1201 # The Cygwin build does not have generators for Visual Studio, so
1202 # detect that here and error.
1203 if ! "$CFG_CMAKE" --help | sed -n '/^Generators/,$p' | grep 'Visual Studio' > /dev/null
1204 then
1205 err "
1206
1207cmake does not support Visual Studio generators.
1208
1209This is likely due to it being an msys/cygwin build of cmake, \
1210rather than the required windows version, built using MinGW \
1211or Visual Studio.
1212
1213If you are building under msys2 try installing the mingw-w64-x86_64-cmake \
1214package instead of cmake:
1215
1216$ pacman -R cmake && pacman -S mingw-w64-x86_64-cmake
1217"
1218 fi
1219
62682a34
SL
1220 # Use the REG program to figure out where VS is installed
1221 # We need to figure out where cl.exe and link.exe are, so we do some
1222 # munging and some probing here. We also look for the default
1223 # INCLUDE and LIB variables for MSVC so we can set those in the
1224 # build system as well.
e9174d1e 1225 install=$(cmd //c reg QUERY \
c1a9b12d 1226 'HKLM\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\14.0' \
62682a34 1227 -v InstallDir)
c1a9b12d 1228 if [ -z "$install" ]; then
e9174d1e 1229 install=$(cmd //c reg QUERY \
c1a9b12d
SL
1230 'HKLM\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\12.0' \
1231 -v InstallDir)
1232 fi
62682a34
SL
1233 need_ok "couldn't find visual studio install root"
1234 CFG_MSVC_ROOT=$(echo "$install" | grep InstallDir | sed 's/.*REG_SZ[ ]*//')
1235 CFG_MSVC_ROOT=$(dirname "$CFG_MSVC_ROOT")
1236 CFG_MSVC_ROOT=$(dirname "$CFG_MSVC_ROOT")
c1a9b12d
SL
1237 putvar CFG_MSVC_ROOT
1238
1239 case $i in
1240 x86_64-*)
1241 bits=x86_64
1242 msvc_part=amd64
1243 ;;
54a0048b 1244 i*86-*)
c1a9b12d
SL
1245 bits=i386
1246 msvc_part=
1247 ;;
1248 *)
1249 err "can only target x86 targets for MSVC"
1250 ;;
1251 esac
1252 bindir="${CFG_MSVC_ROOT}/VC/bin"
1253 if [ -n "$msvc_part" ]; then
1254 bindir="$bindir/$msvc_part"
1255 fi
1256 eval CFG_MSVC_BINDIR_$bits="\"$bindir\""
1257 eval CFG_MSVC_CL_$bits="\"$bindir/cl.exe\""
1258 eval CFG_MSVC_LIB_$bits="\"$bindir/lib.exe\""
1259 eval CFG_MSVC_LINK_$bits="\"$bindir/link.exe\""
62682a34
SL
1260
1261 vcvarsall="${CFG_MSVC_ROOT}/VC/vcvarsall.bat"
e9174d1e 1262 include_path=$(cmd //V:ON //c "$vcvarsall" $msvc_part \& echo !INCLUDE!)
62682a34 1263 need_ok "failed to learn about MSVC's INCLUDE"
e9174d1e 1264 lib_path=$(cmd //V:ON //c "$vcvarsall" $msvc_part \& echo !LIB!)
62682a34
SL
1265 need_ok "failed to learn about MSVC's LIB"
1266
c1a9b12d
SL
1267 eval CFG_MSVC_INCLUDE_PATH_${bits}="\"$include_path\""
1268 eval CFG_MSVC_LIB_PATH_${bits}="\"$lib_path\""
1269
1270 putvar CFG_MSVC_BINDIR_${bits}
1271 putvar CFG_MSVC_CL_${bits}
1272 putvar CFG_MSVC_LIB_${bits}
1273 putvar CFG_MSVC_LINK_${bits}
1274 putvar CFG_MSVC_INCLUDE_PATH_${bits}
1275 putvar CFG_MSVC_LIB_PATH_${bits}
62682a34
SL
1276 ;;
1277
223e47cc
LB
1278 *)
1279 ;;
1280 esac
1281done
1282
c1a9b12d 1283if [ -n "$CFG_PERF" ]
223e47cc
LB
1284then
1285 HAVE_PERF_LOGFD=`$CFG_PERF stat --log-fd 2>&1 | grep 'unknown option'`
1286 if [ -z "$HAVE_PERF_LOGFD" ];
1287 then
1288 CFG_PERF_WITH_LOGFD=1
1289 putvar CFG_PERF_WITH_LOGFD
1290 fi
1291fi
1292
7453a54e 1293if [ -z "$CFG_ENABLE_RUSTBUILD" ]; then
223e47cc 1294
7453a54e 1295 step_msg "making directories"
223e47cc 1296
7453a54e
SL
1297 for i in \
1298 doc doc/std doc/extra \
1299 dl tmp dist
1300 do
1301 make_dir $i
1302 done
223e47cc 1303
7453a54e
SL
1304 for t in $CFG_HOST
1305 do
1306 make_dir $t/llvm
1307 done
223e47cc 1308
7453a54e 1309 for t in $CFG_HOST
223e47cc 1310 do
7453a54e 1311 make_dir $t/rustllvm
223e47cc 1312 done
223e47cc 1313
7453a54e
SL
1314 for t in $CFG_TARGET
1315 do
1316 make_dir $t/rt
1317 for s in 0 1 2 3
223e47cc 1318 do
7453a54e
SL
1319 make_dir $t/rt/stage$s
1320 make_dir $t/rt/jemalloc
1321 make_dir $t/rt/compiler-rt
1322 for i in \
1323 isaac sync test \
1324 arch/i386 arch/x86_64 arch/arm arch/aarch64 arch/mips arch/powerpc
1325 do
1326 make_dir $t/rt/stage$s/$i
1327 done
223e47cc 1328 done
7453a54e 1329 done
223e47cc 1330
7453a54e
SL
1331 for h in $CFG_HOST
1332 do
1333 for t in $CFG_TARGET
1334 do
1335 # host bin dir stage0
1336 make_dir $h/stage0/bin
1337
1338 # host lib dir stage0
1339 make_dir $h/stage0/lib
1340
1341 # host test dir stage0
1342 make_dir $h/stage0/test
1343
1344 # target bin dir stage0
1345 make_dir $h/stage0/lib/rustlib/$t/bin
1346
1347 # target lib dir stage0
1348 make_dir $h/stage0/lib/rustlib/$t/lib
1349
1350 for i in 1 2 3
1351 do
1352 # host bin dir
1353 make_dir $h/stage$i/bin
1354
1355 # host lib dir
1356 make_dir $h/stage$i/$CFG_LIBDIR_RELATIVE
1357
1358 # host test dir
1359 make_dir $h/stage$i/test
1360
1361 # target bin dir
1362 make_dir $h/stage$i/$CFG_LIBDIR_RELATIVE/rustlib/$t/bin
1363
1364 # target lib dir
1365 make_dir $h/stage$i/$CFG_LIBDIR_RELATIVE/rustlib/$t/lib
1366 done
1367 done
1368
1369 make_dir $h/test/run-pass
1370 make_dir $h/test/run-pass-valgrind
1371 make_dir $h/test/run-pass-fulldeps
1372 make_dir $h/test/run-fail
1373 make_dir $h/test/run-fail-fulldeps
1374 make_dir $h/test/compile-fail
1375 make_dir $h/test/parse-fail
1376 make_dir $h/test/compile-fail-fulldeps
1377 make_dir $h/test/bench
1378 make_dir $h/test/perf
1379 make_dir $h/test/pretty
1380 make_dir $h/test/debuginfo-gdb
1381 make_dir $h/test/debuginfo-lldb
1382 make_dir $h/test/codegen
1383 make_dir $h/test/codegen-units
1384 make_dir $h/test/rustdoc
1385 done
1386
1387fi
223e47cc
LB
1388
1389# Configure submodules
1390step_msg "configuring submodules"
1391
1392# Have to be in the top of src directory for this
7453a54e 1393if [ -z $CFG_DISABLE_MANAGE_SUBMODULES ] && [ -z $CFG_ENABLE_RUSTBUILD ]
223e47cc
LB
1394then
1395 cd ${CFG_SRC_DIR}
1396
1397 msg "git: submodule sync"
1a4d82fc
JJ
1398 "${CFG_GIT}" submodule sync
1399
1400 msg "git: submodule init"
1401 "${CFG_GIT}" submodule init
1402
1403 # Disable submodules that we're not using
c1a9b12d 1404 if [ -n "${CFG_LLVM_ROOT}" ]; then
1a4d82fc
JJ
1405 msg "git: submodule deinit src/llvm"
1406 "${CFG_GIT}" submodule deinit src/llvm
1407 fi
c1a9b12d 1408 if [ -n "${CFG_JEMALLOC_ROOT}" ]; then
1a4d82fc
JJ
1409 msg "git: submodule deinit src/jemalloc"
1410 "${CFG_GIT}" submodule deinit src/jemalloc
1411 fi
223e47cc
LB
1412
1413 msg "git: submodule update"
1a4d82fc 1414 "${CFG_GIT}" submodule update
223e47cc
LB
1415 need_ok "git failed"
1416
1417 msg "git: submodule foreach sync"
1a4d82fc 1418 "${CFG_GIT}" submodule foreach --recursive 'if test -e .gitmodules; then git submodule sync; fi'
223e47cc
LB
1419 need_ok "git failed"
1420
1421 msg "git: submodule foreach update"
1a4d82fc 1422 "${CFG_GIT}" submodule update --recursive
223e47cc
LB
1423 need_ok "git failed"
1424
1425 # NB: this is just for the sake of getting the submodule SHA1 values
1426 # and status written into the build log.
1427 msg "git: submodule status"
1428 "${CFG_GIT}" submodule status --recursive
1429
1430 msg "git: submodule clobber"
1a4d82fc 1431 "${CFG_GIT}" submodule foreach --recursive git clean -dxf
223e47cc 1432 need_ok "git failed"
1a4d82fc 1433 "${CFG_GIT}" submodule foreach --recursive git checkout .
223e47cc
LB
1434 need_ok "git failed"
1435
1436 cd ${CFG_BUILD_DIR}
1437fi
1438
1439# Configure llvm, only if necessary
1440step_msg "looking at LLVM"
1441CFG_LLVM_SRC_DIR=${CFG_SRC_DIR}src/llvm/
1a4d82fc 1442for t in $CFG_HOST
223e47cc
LB
1443do
1444 do_reconfigure=1
62682a34
SL
1445 is_msvc=0
1446 case "$t" in
1447 (*-msvc)
1448 is_msvc=1
1449 ;;
1450 esac
223e47cc 1451
7453a54e
SL
1452 if [ -n "$CFG_ENABLE_RUSTBUILD" ]
1453 then
1454 msg "not configuring LLVM, rustbuild in use"
1455 do_reconfigure=0
1456 elif [ -z $CFG_LLVM_ROOT ]
223e47cc 1457 then
1a4d82fc 1458 LLVM_BUILD_DIR=${CFG_BUILD_DIR}$t/llvm
c1a9b12d 1459 if [ -n "$CFG_DISABLE_OPTIMIZE_LLVM" ]
223e47cc
LB
1460 then
1461 LLVM_DBG_OPTS="--enable-debug-symbols --disable-optimized"
1462 # Just use LLVM straight from its build directory to
1463 # avoid 'make install' time
1a4d82fc 1464 LLVM_INST_DIR=$LLVM_BUILD_DIR/Debug
223e47cc
LB
1465 else
1466 LLVM_DBG_OPTS="--enable-optimized"
1a4d82fc
JJ
1467 LLVM_INST_DIR=$LLVM_BUILD_DIR/Release
1468 fi
9346a6ac 1469 if [ -z "$CFG_ENABLE_LLVM_ASSERTIONS" ]
1a4d82fc
JJ
1470 then
1471 LLVM_ASSERTION_OPTS="--disable-assertions"
1472 else
1473 LLVM_ASSERTION_OPTS="--enable-assertions"
62682a34
SL
1474
1475 # Apparently even if we request assertions be enabled for MSVC,
1476 # LLVM's CMake build system ignore this and outputs in `Release`
1477 # anyway.
1478 if [ ${is_msvc} -eq 0 ]; then
1479 LLVM_INST_DIR=${LLVM_INST_DIR}+Asserts
1480 fi
223e47cc
LB
1481 fi
1482 else
1483 msg "not reconfiguring LLVM, external LLVM root"
1484 # The user is using their own LLVM
1485 LLVM_BUILD_DIR=
1486 LLVM_INST_DIR=$CFG_LLVM_ROOT
1487 do_reconfigure=0
e9174d1e 1488 # Check that LLVm FileCheck is available. Needed for the tests
54a0048b
SL
1489 if [ -z "$CFG_DISABLE_CODEGEN_TESTS" ]; then
1490 need_cmd $LLVM_INST_DIR/bin/FileCheck
1491 fi
223e47cc
LB
1492 fi
1493
223e47cc
LB
1494 if [ ${do_reconfigure} -ne 0 ]
1495 then
1496 # because git is hilarious, it might have put the module index
1497 # in a couple places.
1498 index1="${CFG_SRC_DIR}.git/modules/src/llvm/index"
1499 index2="${CFG_SRC_DIR}src/llvm/.git/index"
1500 for index in ${index1} ${index2}
1501 do
1a4d82fc 1502 config_status="${LLVM_BUILD_DIR}/config.status"
223e47cc
LB
1503 if test -e ${index} -a \
1504 -e ${config_status} -a \
1505 ${config_status} -nt ${index}
1506 then
1507 msg "not reconfiguring LLVM, config.status is fresh"
1508 do_reconfigure=0
1509 fi
1510 done
1511 fi
1512
92a42be0
SL
1513 # We need the generator later on for compiler-rt even if LLVM's not built
1514 if [ ${is_msvc} -ne 0 ]
62682a34 1515 then
c1a9b12d
SL
1516 case "$CFG_MSVC_ROOT" in
1517 *14.0*)
1518 generator="Visual Studio 14 2015"
1519 ;;
1520 *12.0*)
1521 generator="Visual Studio 12 2013"
1522 ;;
1523 *)
1524 err "can't determine generator for LLVM cmake"
1525 ;;
1526 esac
1527 case "$t" in
1528 x86_64-*)
1529 generator="$generator Win64"
1530 ;;
1531 i686-*)
1532 ;;
1533 *)
1534 err "can only build LLVM for x86 platforms"
1535 ;;
1536 esac
92a42be0
SL
1537 CFG_CMAKE_GENERATOR=$generator
1538 putvar CFG_CMAKE_GENERATOR
1539 fi
1540
1541 if [ ${do_reconfigure} -ne 0 ] && [ ${is_msvc} -ne 0 ]
1542 then
1543 msg "configuring LLVM for $t with cmake"
1544
1545 CMAKE_ARGS="-DLLVM_INCLUDE_TESTS=OFF"
1546 if [ -n "$CFG_DISABLE_OPTIMIZE_LLVM" ]; then
1547 CMAKE_ARGS="$CMAKE_ARGS -DCMAKE_BUILD_TYPE=Debug"
1548 else
1549 CMAKE_ARGS="$CMAKE_ARGS -DCMAKE_BUILD_TYPE=Release"
1550 fi
1551 if [ -z "$CFG_ENABLE_LLVM_ASSERTIONS" ]
1552 then
1553 CMAKE_ARGS="$CMAKE_ARGS -DLLVM_ENABLE_ASSERTIONS=OFF"
1554 else
1555 CMAKE_ARGS="$CMAKE_ARGS -DLLVM_ENABLE_ASSERTIONS=ON"
1556 fi
1557
1558 msg "configuring LLVM with:"
1559 msg "$CMAKE_ARGS"
1560
62682a34 1561 (cd $LLVM_BUILD_DIR && "$CFG_CMAKE" $CFG_LLVM_SRC_DIR \
92a42be0 1562 -G "$CFG_CMAKE_GENERATOR" \
62682a34
SL
1563 $CMAKE_ARGS)
1564 need_ok "LLVM cmake configure failed"
1565 fi
1566
1567 if [ ${do_reconfigure} -ne 0 ] && [ ${is_msvc} -eq 0 ]
223e47cc 1568 then
1a4d82fc
JJ
1569 # LLVM's configure doesn't recognize the new Windows triples yet
1570 gnu_t=$(to_gnu_triple $t)
1571
1572 msg "configuring LLVM for $gnu_t"
223e47cc 1573
85aaf69f 1574 LLVM_TARGETS="--enable-targets=x86,x86_64,arm,aarch64,mips,powerpc"
1a4d82fc
JJ
1575 LLVM_BUILD="--build=$gnu_t"
1576 LLVM_HOST="--host=$gnu_t"
1577 LLVM_TARGET="--target=$gnu_t"
223e47cc
LB
1578
1579 # Disable unused LLVM features
1a4d82fc
JJ
1580 LLVM_OPTS="$LLVM_DBG_OPTS $LLVM_ASSERTION_OPTS --disable-docs --enable-bindings=none"
1581 # Disable term-info, linkage of which comes in multiple forms,
1582 # making our snapshots incompatible (#9334)
1583 LLVM_OPTS="$LLVM_OPTS --disable-terminfo"
1584 # Try to have LLVM pull in as few dependencies as possible (#9397)
1585 LLVM_OPTS="$LLVM_OPTS --disable-zlib --disable-libffi"
1586
1587 # Use win32 native thread/lock apis instead of pthread wrapper.
1588 # (llvm's configure tries to find pthread first, so we have to disable it explicitly.)
1589 # Also note that pthreads works badly on mingw-w64 systems: #8996
1590 case "$CFG_BUILD" in
62682a34 1591 (*-windows-gnu)
1a4d82fc
JJ
1592 LLVM_OPTS="$LLVM_OPTS --disable-pthreads"
1593 ;;
1594 esac
223e47cc 1595
1a4d82fc 1596 case "$CFG_CC" in
970d7e83 1597 ("ccache clang")
1a4d82fc
JJ
1598 LLVM_CXX_32="ccache clang++ -Qunused-arguments"
1599 LLVM_CC_32="ccache clang -Qunused-arguments"
970d7e83
LB
1600
1601 LLVM_CXX_64="ccache clang++ -Qunused-arguments"
1602 LLVM_CC_64="ccache clang -Qunused-arguments"
1603 ;;
1604 ("clang")
1a4d82fc
JJ
1605 LLVM_CXX_32="clang++ -Qunused-arguments"
1606 LLVM_CC_32="clang -Qunused-arguments"
223e47cc 1607
1a4d82fc
JJ
1608 LLVM_CXX_64="clang++ -Qunused-arguments"
1609 LLVM_CC_64="clang -Qunused-arguments"
970d7e83
LB
1610 ;;
1611 ("ccache gcc")
1a4d82fc
JJ
1612 LLVM_CXX_32="ccache g++"
1613 LLVM_CC_32="ccache gcc"
970d7e83
LB
1614
1615 LLVM_CXX_64="ccache g++"
1616 LLVM_CC_64="ccache gcc"
1617 ;;
1618 ("gcc")
1a4d82fc
JJ
1619 LLVM_CXX_32="g++"
1620 LLVM_CC_32="gcc"
223e47cc
LB
1621
1622 LLVM_CXX_64="g++"
1623 LLVM_CC_64="gcc"
1a4d82fc
JJ
1624 ;;
1625
1626 (*)
1627 msg "inferring LLVM_CXX/CC from CXX/CC = $CXX/$CC"
c1a9b12d
SL
1628 if [ -n "$CFG_ENABLE_CCACHE" ]
1629 then
1630 if [ -z "$CFG_CCACHE" ]
1631 then
1632 err "ccache requested but not found"
1633 fi
1634
1635 LLVM_CXX_32="ccache $CXX"
1636 LLVM_CC_32="ccache $CC"
1637
1638 LLVM_CXX_64="ccache $CXX"
1639 LLVM_CC_64="ccache $CC"
1640 else
1641 LLVM_CXX_32="$CXX"
1642 LLVM_CC_32="$CC"
1643
1644 LLVM_CXX_64="$CXX"
1645 LLVM_CC_64="$CC"
1646 fi
1a4d82fc 1647
1a4d82fc 1648 ;;
970d7e83 1649 esac
223e47cc 1650
1a4d82fc
JJ
1651 case "$CFG_CPUTYPE" in
1652 (x86*)
1653 LLVM_CXX_32="$LLVM_CXX_32 -m32"
1654 LLVM_CC_32="$LLVM_CC_32 -m32"
1655
1656 LLVM_CFLAGS_32="-m32"
1657 LLVM_CXXFLAGS_32="-m32"
1658 LLVM_LDFLAGS_32="-m32"
223e47cc 1659
1a4d82fc
JJ
1660 LLVM_CFLAGS_64=""
1661 LLVM_CXXFLAGS_64=""
1662 LLVM_LDFLAGS_64=""
1663
1664 LLVM_CXX_32="$LLVM_CXX_32 -m32"
1665 LLVM_CC_32="$LLVM_CC_32 -m32"
1666 ;;
1667
1668 (*)
1669 LLVM_CFLAGS_32=""
1670 LLVM_CXXFLAGS_32=""
1671 LLVM_LDFLAGS_32=""
1672
1673 LLVM_CFLAGS_64=""
1674 LLVM_CXXFLAGS_64=""
1675 LLVM_LDFLAGS_64=""
1676 ;;
1677 esac
223e47cc
LB
1678
1679 if echo $t | grep -q x86_64
1680 then
1681 LLVM_CXX=$LLVM_CXX_64
1682 LLVM_CC=$LLVM_CC_64
1683 LLVM_CFLAGS=$LLVM_CFLAGS_64
1684 LLVM_CXXFLAGS=$LLVM_CXXFLAGS_64
1685 LLVM_LDFLAGS=$LLVM_LDFLAGS_64
1686 else
1687 LLVM_CXX=$LLVM_CXX_32
1688 LLVM_CC=$LLVM_CC_32
1689 LLVM_CFLAGS=$LLVM_CFLAGS_32
1690 LLVM_CXXFLAGS=$LLVM_CXXFLAGS_32
1691 LLVM_LDFLAGS=$LLVM_LDFLAGS_32
1692 fi
1693
1694 CXX=$LLVM_CXX
1695 CC=$LLVM_CC
92a42be0
SL
1696 CFLAGS="$CFLAGS $LLVM_CFLAGS"
1697 CXXFLAGS="$CXXFLAGS $LLVM_CXXFLAGS"
1698 LDFLAGS="$LDFLAGS $LLVM_LDFLAGS"
223e47cc 1699
9cc50fc6 1700 if [ "$CFG_USING_LIBCPP" != "0" ]; then
1a4d82fc
JJ
1701 LLVM_OPTS="$LLVM_OPTS --enable-libcpp"
1702 fi
1703
223e47cc 1704 LLVM_FLAGS="$LLVM_TARGETS $LLVM_OPTS $LLVM_BUILD \
970d7e83 1705 $LLVM_HOST $LLVM_TARGET --with-python=$CFG_PYTHON"
223e47cc
LB
1706
1707 msg "configuring LLVM with:"
1708 msg "$LLVM_FLAGS"
1709
1710 export CXX
1711 export CC
1712 export CFLAGS
1713 export CXXFLAGS
1714 export LDFLAGS
1715
1716 cd $LLVM_BUILD_DIR
1717 case $CFG_SRC_DIR in
1718 /* | [a-z]:* | [A-Z]:*)
1719 ${CFG_LLVM_SRC_DIR}configure $LLVM_FLAGS
1720 ;;
1721 *)
1722 ${CFG_BUILD_DIR}${CFG_LLVM_SRC_DIR}configure \
1723 $LLVM_FLAGS
1724 ;;
1725 esac
1726 need_ok "LLVM configure failed"
1727
223e47cc
LB
1728 cd $CFG_BUILD_DIR
1729 fi
1730
1731 # Construct variables for LLVM build and install directories for
1732 # each target. These will be named
1733 # CFG_LLVM_BUILD_DIR_${target_triple} but all the hyphens in
1734 # target_triple will be converted to underscore, because bash
1735 # variables can't contain hyphens. The makefile will then have to
1736 # convert back.
1737 CFG_LLVM_BUILD_DIR=$(echo CFG_LLVM_BUILD_DIR_${t} | tr - _)
1738 CFG_LLVM_INST_DIR=$(echo CFG_LLVM_INST_DIR_${t} | tr - _)
1739 eval ${CFG_LLVM_BUILD_DIR}="'$LLVM_BUILD_DIR'"
1740 eval ${CFG_LLVM_INST_DIR}="'$LLVM_INST_DIR'"
1741done
1742
1743
1744step_msg "writing configuration"
1745
1746putvar CFG_SRC_DIR
62682a34 1747putvar CFG_SRC_DIR_RELATIVE
223e47cc
LB
1748putvar CFG_BUILD_DIR
1749putvar CFG_OSTYPE
1750putvar CFG_CPUTYPE
1751putvar CFG_CONFIGURE_ARGS
1752putvar CFG_PREFIX
1a4d82fc
JJ
1753putvar CFG_HOST
1754putvar CFG_TARGET
1755putvar CFG_LIBDIR_RELATIVE
223e47cc 1756putvar CFG_DISABLE_MANAGE_SUBMODULES
c1a9b12d
SL
1757putvar CFG_AARCH64_LINUX_ANDROID_NDK
1758putvar CFG_ARM_LINUX_ANDROIDEABI_NDK
e9174d1e 1759putvar CFG_I686_LINUX_ANDROID_NDK
9cc50fc6 1760putvar CFG_NACL_CROSS_PATH
1a4d82fc 1761putvar CFG_MANDIR
9cc50fc6 1762putvar CFG_USING_LIBCPP
223e47cc 1763
970d7e83
LB
1764# Avoid spurious warnings from clang by feeding it original source on
1765# ccache-miss rather than preprocessed input.
c1a9b12d 1766if [ -n "$CFG_ENABLE_CCACHE" ] && [ -n "$CFG_USING_CLANG" ]
970d7e83
LB
1767then
1768 CFG_CCACHE_CPP2=1
1769 putvar CFG_CCACHE_CPP2
1770fi
1771
c1a9b12d 1772if [ -n "$CFG_ENABLE_CCACHE" ]
970d7e83
LB
1773then
1774 CFG_CCACHE_BASEDIR=${CFG_SRC_DIR}
1775 putvar CFG_CCACHE_BASEDIR
1776fi
1777
1778
223e47cc
LB
1779putvar CFG_LLVM_SRC_DIR
1780
1a4d82fc 1781for t in $CFG_HOST
223e47cc
LB
1782do
1783 CFG_LLVM_BUILD_DIR=$(echo CFG_LLVM_BUILD_DIR_${t} | tr - _)
1784 CFG_LLVM_INST_DIR=$(echo CFG_LLVM_INST_DIR_${t} | tr - _)
1785 putvar $CFG_LLVM_BUILD_DIR
1786 putvar $CFG_LLVM_INST_DIR
1787done
1788
7453a54e
SL
1789if [ -n "$CFG_ENABLE_RUSTBUILD" ]
1790then
1791 INPUT_MAKEFILE=src/bootstrap/mk/Makefile.in
1792else
1793 INPUT_MAKEFILE=Makefile.in
1794fi
1795
223e47cc 1796msg
7453a54e 1797copy_if_changed ${CFG_SRC_DIR}${INPUT_MAKEFILE} ./Makefile
223e47cc
LB
1798move_if_changed config.tmp config.mk
1799rm -f config.tmp
1800touch config.stamp
1801
9346a6ac
AL
1802if [ -z "$CFG_ENABLE_DEBUG" ]; then
1803 step_msg "configured in release mode. for development consider --enable-debug"
1804else
1805 step_msg "complete"
1806fi
1807
1a4d82fc
JJ
1808msg "run \`make help\`"
1809msg