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