]>
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 | ||
544 | OPTIONS="" | |
545 | HELP=0 | |
546 | if [ "$1" = "--help" ] | |
547 | then | |
548 | HELP=1 | |
549 | shift | |
970d7e83 | 550 | echo |
223e47cc | 551 | echo "Usage: $CFG_SELF [options]" |
970d7e83 | 552 | echo |
223e47cc | 553 | echo "Options:" |
970d7e83 | 554 | echo |
223e47cc LB |
555 | else |
556 | msg "recreating config.tmp" | |
557 | echo '' >config.tmp | |
558 | ||
559 | step_msg "processing $CFG_SELF args" | |
560 | fi | |
561 | ||
562 | BOOL_OPTIONS="" | |
563 | VAL_OPTIONS="" | |
564 | ||
d9579d0f | 565 | opt debug 0 "debug mode; disables optimization unless \`--enable-optimize\` given" |
223e47cc LB |
566 | opt valgrind 0 "run tests with valgrind (memcheck by default)" |
567 | opt helgrind 0 "run tests with helgrind instead of memcheck" | |
1a4d82fc | 568 | opt valgrind-rpass 1 "run rpass-valgrind tests with valgrind" |
c34b1796 AL |
569 | opt docs 1 "build standard library documentation" |
570 | opt compiler-docs 0 "build compiler documentation" | |
1a4d82fc | 571 | opt optimize-tests 1 "build tests with optimizations" |
d9579d0f | 572 | opt debuginfo-tests 0 "build tests with debugger metadata" |
1a4d82fc | 573 | opt libcpp 1 "build with llvm with libc++ instead of libstdc++ when using clang" |
9346a6ac AL |
574 | opt llvm-assertions 0 "build LLVM with assertions" |
575 | opt debug-assertions 0 "build with debugging assertions" | |
223e47cc | 576 | opt fast-make 0 "use .gitmodules as timestamp for submodule deps" |
970d7e83 | 577 | opt ccache 0 "invoke gcc/clang via ccache to reuse object files between builds" |
223e47cc | 578 | opt local-rust 0 "use an installed rustc rather than downloading a snapshot" |
1a4d82fc JJ |
579 | opt llvm-static-stdcpp 0 "statically link to libstdc++ for LLVM" |
580 | opt rpath 0 "build rpaths into rustc itself" | |
1a4d82fc JJ |
581 | # This is used by the automation to produce single-target nightlies |
582 | opt dist-host-only 0 "only install bins for the host architecture" | |
583 | opt inject-std-version 1 "inject the current compiler version of libstd into programs" | |
62682a34 | 584 | opt llvm-version-check 1 "check if the LLVM version is supported, build anyway" |
1a4d82fc | 585 | |
9346a6ac AL |
586 | # Optimization and debugging options. These may be overridden by the release channel, etc. |
587 | opt_nosave optimize 1 "build optimized rust code" | |
588 | opt_nosave optimize-cxx 1 "build optimized C++ code" | |
589 | opt_nosave optimize-llvm 1 "build optimized LLVM" | |
590 | opt_nosave llvm-assertions 0 "build LLVM with assertions" | |
591 | opt_nosave debug-assertions 0 "build with debugging assertions" | |
592 | opt_nosave debuginfo 0 "build with debugger metadata" | |
593 | opt_nosave debug-jemalloc 0 "build jemalloc with --enable-debug --enable-fill" | |
594 | ||
1a4d82fc JJ |
595 | valopt localstatedir "/var/lib" "local state directory" |
596 | valopt sysconfdir "/etc" "install system configuration files" | |
597 | ||
598 | valopt datadir "${CFG_PREFIX}/share" "install data" | |
599 | valopt infodir "${CFG_PREFIX}/share/info" "install additional info" | |
223e47cc | 600 | valopt llvm-root "" "set LLVM root" |
62682a34 | 601 | valopt python "" "set path to python" |
1a4d82fc JJ |
602 | valopt jemalloc-root "" "set directory where libjemalloc_pic.a is located" |
603 | valopt build "${DEFAULT_BUILD}" "GNUs ./configure syntax LLVM build triple" | |
c1a9b12d SL |
604 | valopt android-cross-path "/opt/ndk_standalone" "Android NDK standalone path (deprecated)" |
605 | valopt arm-linux-androideabi-ndk "" "arm-linux-androideabi NDK standalone path" | |
606 | valopt aarch64-linux-android-ndk "" "aarch64-linux-android NDK standalone path" | |
9346a6ac | 607 | valopt release-channel "dev" "the name of the release channel to build" |
d9579d0f | 608 | valopt musl-root "/usr/local" "MUSL root installation directory" |
223e47cc | 609 | |
1a4d82fc JJ |
610 | # Many of these are saved below during the "writing configuration" step |
611 | # (others are conditionally saved). | |
612 | opt_nosave manage-submodules 1 "let the build manage the git submodules" | |
613 | opt_nosave clang 0 "prefer clang to gcc for building the runtime" | |
9346a6ac | 614 | opt_nosave jemalloc 1 "build liballoc with jemalloc" |
d9579d0f | 615 | opt elf-tls 1 "elf thread local storage on platforms where supported" |
1a4d82fc JJ |
616 | |
617 | valopt_nosave prefix "/usr/local" "set installation prefix" | |
618 | valopt_nosave local-rust-root "/usr/local" "set prefix for local rust binary" | |
619 | valopt_nosave host "${CFG_BUILD}" "GNUs ./configure syntax LLVM host triples" | |
620 | valopt_nosave target "${CFG_HOST}" "GNUs ./configure syntax LLVM target triples" | |
621 | valopt_nosave mandir "${CFG_PREFIX}/share/man" "install man pages in PATH" | |
1a4d82fc JJ |
622 | |
623 | # Temporarily support old triples until buildbots get updated | |
624 | CFG_BUILD=$(to_llvm_triple $CFG_BUILD) | |
625 | putvar CFG_BUILD # Yes, this creates a duplicate entry, but the last one wins. | |
626 | CFG_HOST=$(to_llvm_triple $CFG_HOST) | |
627 | CFG_TARGET=$(to_llvm_triple $CFG_TARGET) | |
628 | ||
629 | # On windows we just store the libraries in the bin directory because | |
630 | # there's no rpath. This is where the build system itself puts libraries; | |
631 | # --libdir is used to configure the installation directory. | |
632 | # FIXME: This needs to parameterized over target triples. Do it in platform.mk | |
62682a34 | 633 | if [ "$CFG_OSTYPE" = "pc-windows-gnu" ] || [ "$CFG_OSTYPE" = "pc-windows-msvc" ] |
1a4d82fc JJ |
634 | then |
635 | CFG_LIBDIR_RELATIVE=bin | |
636 | else | |
637 | CFG_LIBDIR_RELATIVE=lib | |
638 | fi | |
639 | ||
640 | valopt libdir "${CFG_PREFIX}/${CFG_LIBDIR_RELATIVE}" "install libraries (do not set it on windows platform)" | |
641 | ||
642 | case "$CFG_LIBDIR" in | |
643 | "$CFG_PREFIX"/*) CAT_INC=2;; | |
644 | "$CFG_PREFIX"*) CAT_INC=1;; | |
645 | *) | |
646 | err "libdir must begin with the prefix. Use --prefix to set it accordingly.";; | |
647 | esac | |
648 | ||
649 | CFG_LIBDIR_RELATIVE=`echo ${CFG_LIBDIR} | cut -c$((${#CFG_PREFIX}+${CAT_INC}))-` | |
650 | ||
62682a34 SL |
651 | if ( [ "$CFG_OSTYPE" = "pc-windows-gnu" ] || [ "$CFG_OSTYPE" = "pc-windows-msvc" ] ) \ |
652 | && [ "$CFG_LIBDIR_RELATIVE" != "bin" ]; then | |
1a4d82fc JJ |
653 | err "libdir on windows should be set to 'bin'" |
654 | fi | |
223e47cc LB |
655 | |
656 | if [ $HELP -eq 1 ] | |
657 | then | |
970d7e83 | 658 | echo |
223e47cc LB |
659 | exit 0 |
660 | fi | |
661 | ||
1a4d82fc JJ |
662 | # Validate Options |
663 | step_msg "validating $CFG_SELF args" | |
664 | validate_opt | |
665 | ||
9346a6ac | 666 | # Validate the release channel, and configure options |
1a4d82fc | 667 | case "$CFG_RELEASE_CHANNEL" in |
9346a6ac AL |
668 | nightly ) |
669 | msg "overriding settings for $CFG_RELEASE_CHANNEL" | |
670 | CFG_ENABLE_LLVM_ASSERTIONS=1 | |
1a4d82fc | 671 | ;; |
9346a6ac AL |
672 | dev | beta | stable) |
673 | ;; | |
674 | *) | |
1a4d82fc JJ |
675 | err "release channel must be 'dev', 'nightly', 'beta' or 'stable'" |
676 | ;; | |
677 | esac | |
678 | ||
9346a6ac AL |
679 | # Adjust perf and debug options for debug mode |
680 | if [ -n "$CFG_ENABLE_DEBUG" ]; then | |
681 | msg "debug mode enabled, setting performance options" | |
682 | if [ -z "$CFG_ENABLE_OPTIMIZE_PROVIDED" ]; then | |
683 | msg "optimization not explicitly enabled, disabling optimization" | |
684 | CFG_DISABLE_OPTIMIZE=1 | |
685 | CFG_DISABLE_OPTIMIZE_CXX=1 | |
686 | fi | |
c1a9b12d SL |
687 | |
688 | # Set following variables to 1 unless setting already provided | |
689 | enable_if_not_disabled debug-assertions | |
690 | enable_if_not_disabled debug-jemalloc | |
691 | enable_if_not_disabled debuginfo | |
692 | enable_if_not_disabled llvm-assertions | |
1a4d82fc | 693 | fi |
9346a6ac AL |
694 | |
695 | # OK, now write the debugging options | |
696 | if [ -n "$CFG_DISABLE_OPTIMIZE" ]; then putvar CFG_DISABLE_OPTIMIZE; fi | |
697 | if [ -n "$CFG_DISABLE_OPTIMIZE_CXX" ]; then putvar CFG_DISABLE_OPTIMIZE_CXX; fi | |
698 | if [ -n "$CFG_DISABLE_OPTIMIZE_LLVM" ]; then putvar CFG_DISABLE_OPTIMIZE_LLVM; fi | |
699 | if [ -n "$CFG_ENABLE_LLVM_ASSERTIONS" ]; then putvar CFG_ENABLE_LLVM_ASSERTIONS; fi | |
700 | if [ -n "$CFG_ENABLE_DEBUG_ASSERTIONS" ]; then putvar CFG_ENABLE_DEBUG_ASSERTIONS; fi | |
701 | if [ -n "$CFG_ENABLE_DEBUGINFO" ]; then putvar CFG_ENABLE_DEBUGINFO; fi | |
702 | if [ -n "$CFG_ENABLE_DEBUG_JEMALLOC" ]; then putvar CFG_ENABLE_DEBUG_JEMALLOC; fi | |
1a4d82fc JJ |
703 | |
704 | # A magic value that allows the compiler to use unstable features | |
705 | # during the bootstrap even when doing so would normally be an error | |
706 | # because of feature staging or because the build turns on | |
707 | # warnings-as-errors and unstable features default to warnings. The | |
708 | # build has to match this key in an env var. Meant to be a mild | |
709 | # deterrent from users just turning on unstable features on the stable | |
710 | # channel. | |
711 | # Basing CFG_BOOTSTRAP_KEY on CFG_BOOTSTRAP_KEY lets it get picked up | |
712 | # during a Makefile reconfig. | |
85aaf69f | 713 | CFG_BOOTSTRAP_KEY="${CFG_BOOTSTRAP_KEY-`date +%H:%M:%S`}" |
1a4d82fc | 714 | putvar CFG_BOOTSTRAP_KEY |
223e47cc LB |
715 | |
716 | step_msg "looking for build programs" | |
717 | ||
1a4d82fc | 718 | probe_need CFG_CURLORWGET curl wget |
62682a34 SL |
719 | if [ -z "$CFG_PYTHON_PROVIDED" ]; then |
720 | probe_need CFG_PYTHON python2.7 python2.6 python2 python | |
721 | fi | |
223e47cc LB |
722 | |
723 | python_version=$($CFG_PYTHON -V 2>&1) | |
724 | if [ $(echo $python_version | grep -c '^Python 2\.[4567]') -ne 1 ]; then | |
725 | err "Found $python_version, but LLVM requires Python 2.4-2.7" | |
726 | fi | |
727 | ||
728 | # If we have no git directory then we are probably a tarball distribution | |
729 | # and shouldn't attempt to load submodules | |
730 | if [ ! -e ${CFG_SRC_DIR}.git ] | |
731 | then | |
732 | probe CFG_GIT git | |
733 | msg "git: no git directory. disabling submodules" | |
734 | CFG_DISABLE_MANAGE_SUBMODULES=1 | |
735 | else | |
736 | probe_need CFG_GIT git | |
737 | fi | |
738 | ||
d9579d0f AL |
739 | # Use `md5sum` on GNU platforms, or `md5 -q` on BSD |
740 | probe CFG_MD5 md5 | |
741 | probe CFG_MD5SUM md5sum | |
742 | if [ -n "$CFG_MD5" ] | |
743 | then | |
62682a34 | 744 | CFG_HASH_COMMAND="$CFG_MD5 -q | cut -c 1-8" |
d9579d0f AL |
745 | elif [ -n "$CFG_MD5SUM" ] |
746 | then | |
62682a34 | 747 | CFG_HASH_COMMAND="$CFG_MD5SUM | cut -c 1-8" |
d9579d0f AL |
748 | else |
749 | err 'could not find one of: md5 md5sum' | |
750 | fi | |
751 | putvar CFG_HASH_COMMAND | |
752 | ||
223e47cc | 753 | probe CFG_CLANG clang++ |
970d7e83 | 754 | probe CFG_CCACHE ccache |
223e47cc LB |
755 | probe CFG_GCC gcc |
756 | probe CFG_LD ld | |
757 | probe CFG_VALGRIND valgrind | |
758 | probe CFG_PERF perf | |
759 | probe CFG_ISCC iscc | |
1a4d82fc JJ |
760 | probe CFG_ANTLR4 antlr4 |
761 | probe CFG_GRUN grun | |
85aaf69f SL |
762 | probe CFG_FLEX flex |
763 | probe CFG_BISON bison | |
223e47cc | 764 | probe CFG_PANDOC pandoc |
1a4d82fc | 765 | probe CFG_XELATEX xelatex |
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 | ||
c1a9b12d | 824 | if [ -n "$CFG_PANDOC" ] |
223e47cc | 825 | then |
c34b1796 AL |
826 | # Extract "MAJOR MINOR" from Pandoc's version number |
827 | PV_MAJOR_MINOR=$(pandoc --version | grep '^pandoc' | | |
828 | sed -E 's/pandoc(.exe)? ([0-9]+)\.([0-9]+).*/\2 \3/') | |
223e47cc | 829 | |
1a4d82fc JJ |
830 | MIN_PV_MAJOR="1" |
831 | MIN_PV_MINOR="9" | |
c34b1796 | 832 | |
223e47cc LB |
833 | # these patterns are shell globs, *not* regexps |
834 | PV_MAJOR=${PV_MAJOR_MINOR% *} | |
835 | PV_MINOR=${PV_MAJOR_MINOR#* } | |
c34b1796 | 836 | |
1a4d82fc | 837 | if [ "$PV_MAJOR" -lt "$MIN_PV_MAJOR" ] || [ "$PV_MINOR" -lt "$MIN_PV_MINOR" ] |
223e47cc | 838 | then |
1a4d82fc JJ |
839 | step_msg "pandoc $PV_MAJOR.$PV_MINOR is too old. Need at least $MIN_PV_MAJOR.$MIN_PV_MINOR. Disabling" |
840 | BAD_PANDOC=1 | |
223e47cc LB |
841 | fi |
842 | fi | |
843 | ||
1a4d82fc | 844 | BIN_SUF= |
62682a34 | 845 | if [ "$CFG_OSTYPE" = "pc-windows-gnu" ] || [ "$CFG_OSTYPE" = "pc-windows-msvc" ] |
223e47cc | 846 | then |
1a4d82fc | 847 | BIN_SUF=.exe |
223e47cc LB |
848 | fi |
849 | ||
c1a9b12d | 850 | if [ -n "$CFG_ENABLE_LOCAL_RUST" ] |
223e47cc | 851 | then |
1a4d82fc JJ |
852 | system_rustc=$(which rustc) |
853 | if [ -f ${CFG_LOCAL_RUST_ROOT}/bin/rustc${BIN_SUF} ] | |
223e47cc | 854 | then |
1a4d82fc JJ |
855 | : # everything already configured |
856 | elif [ -n "$system_rustc" ] | |
857 | then | |
858 | # we assume that rustc is in a /bin directory | |
859 | CFG_LOCAL_RUST_ROOT=${system_rustc%/bin/rustc} | |
223e47cc | 860 | else |
1a4d82fc | 861 | err "no local rust to use" |
223e47cc | 862 | fi |
1a4d82fc JJ |
863 | |
864 | CMD="${CFG_LOCAL_RUST_ROOT}/bin/rustc${BIN_SUF}" | |
865 | LRV=`$CMD --version` | |
866 | if [ $? -ne 0 ] | |
867 | then | |
868 | step_msg "failure while running $CMD --version" | |
869 | exit 1 | |
870 | fi | |
871 | step_msg "using rustc at: ${CFG_LOCAL_RUST_ROOT} with version: $LRV" | |
872 | putvar CFG_LOCAL_RUST_ROOT | |
223e47cc LB |
873 | fi |
874 | ||
c34b1796 AL |
875 | # Force bitrig to build with clang; gcc doesn't like us there |
876 | if [ $CFG_OSTYPE = unknown-bitrig ] | |
877 | then | |
878 | step_msg "on Bitrig, forcing use of clang, disabling jemalloc" | |
879 | CFG_ENABLE_CLANG=1 | |
9346a6ac | 880 | CFG_DISABLE_JEMALLOC=1 |
c34b1796 AL |
881 | fi |
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. | |
885 | if [ $CFG_OSTYPE = apple-darwin -a -z "$CFG_ENABLE_CLANG" ] | |
886 | then | |
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 | |
919 | fi | |
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. | |
923 | if [ -z "$CFG_ENABLE_CLANG" ] | |
924 | then | |
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 | |
931 | fi | |
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 | 935 | if [ -n "$CFG_ENABLE_CLANG" ] |
1a4d82fc JJ |
936 | then |
937 | putvar CFG_ENABLE_CLANG | |
938 | fi | |
939 | ||
9346a6ac | 940 | # Same with jemalloc. save the setting here. |
c1a9b12d | 941 | if [ -n "$CFG_DISABLE_JEMALLOC" ] |
9346a6ac AL |
942 | then |
943 | putvar CFG_DISABLE_JEMALLOC | |
944 | fi | |
945 | ||
c1a9b12d | 946 | if [ -n "$CFG_LLVM_ROOT" -a -z "$CFG_DISABLE_LLVM_VERSION_CHECK" -a -e "$CFG_LLVM_ROOT/bin/llvm-config" ] |
223e47cc LB |
947 | then |
948 | step_msg "using custom LLVM at $CFG_LLVM_ROOT" | |
949 | ||
950 | LLVM_CONFIG="$CFG_LLVM_ROOT/bin/llvm-config" | |
951 | LLVM_VERSION=$($LLVM_CONFIG --version) | |
952 | ||
953 | case $LLVM_VERSION in | |
c1a9b12d | 954 | (3.[5-7]*) |
1a4d82fc JJ |
955 | msg "found ok version of LLVM: $LLVM_VERSION" |
956 | ;; | |
957 | (*) | |
c34b1796 | 958 | err "bad LLVM version: $LLVM_VERSION, need >=3.5" |
1a4d82fc | 959 | ;; |
223e47cc LB |
960 | esac |
961 | fi | |
962 | ||
1a4d82fc JJ |
963 | # Even when the user overrides the choice of CC, still try to detect |
964 | # clang to disable some clang-specific warnings. We here draw a | |
965 | # distinction between: | |
966 | # | |
967 | # CFG_ENABLE_CLANG : passed --enable-clang, or host "requires" clang, | |
968 | # CFG_USING_CLANG : compiler (clang / gcc / $CC) looks like clang. | |
969 | # | |
970 | # This distinction is important because there are some safeguards we | |
971 | # would prefer to skip when merely CFG_USING_CLANG is set; but when | |
972 | # CFG_ENABLE_CLANG is set, that indicates that we are opting into | |
973 | # running such safeguards. | |
974 | ||
c1a9b12d | 975 | if [ -n "$CC" ] |
223e47cc | 976 | then |
1a4d82fc JJ |
977 | msg "skipping compiler inference steps; using provided CC=$CC" |
978 | CFG_CC="$CC" | |
979 | ||
980 | CFG_OSX_CC_VERSION=$("$CFG_CC" --version 2>&1 | grep "clang") | |
981 | if [ $? -eq 0 ] | |
223e47cc | 982 | then |
1a4d82fc JJ |
983 | step_msg "note, user-provided CC looks like clang; CC=$CC." |
984 | CFG_USING_CLANG=1 | |
985 | putvar CFG_USING_CLANG | |
223e47cc | 986 | fi |
223e47cc | 987 | else |
c1a9b12d | 988 | if [ -n "$CFG_ENABLE_CLANG" ] |
1a4d82fc JJ |
989 | then |
990 | if [ -z "$CFG_CLANG" ] | |
991 | then | |
992 | err "clang requested but not found" | |
993 | fi | |
994 | CFG_CC="$CFG_CLANG" | |
995 | CFG_USING_CLANG=1 | |
996 | putvar CFG_USING_CLANG | |
997 | else | |
998 | CFG_CC="gcc" | |
999 | fi | |
1000 | fi | |
1001 | ||
c1a9b12d | 1002 | if [ -n "$CFG_ENABLE_CLANG" ] |
1a4d82fc | 1003 | then |
62682a34 SL |
1004 | case "$CC" in |
1005 | (''|*clang) | |
1006 | CFG_CLANG_REPORTED_VERSION=$($CFG_CC --version | grep version) | |
1007 | ||
c1a9b12d | 1008 | if echo $CFG_CLANG_REPORTED_VERSION | grep -q "(based on LLVM "; then |
62682a34 | 1009 | CFG_CLANG_VERSION=$(echo $CFG_CLANG_REPORTED_VERSION | sed 's/.*(based on LLVM \(.*\))/\1/') |
c1a9b12d | 1010 | elif echo $CFG_CLANG_REPORTED_VERSION | grep -q "Apple LLVM"; then |
62682a34 SL |
1011 | CFG_OSX_CLANG_VERSION=$(echo $CFG_CLANG_REPORTED_VERSION | sed 's/.*version \(.*\) .*/\1/') |
1012 | else | |
1013 | CFG_CLANG_VERSION=$(echo $CFG_CLANG_REPORTED_VERSION | sed 's/.*version \(.*\) .*/\1/') | |
1014 | fi | |
1015 | ||
c1a9b12d | 1016 | if [ -n "$CFG_OSX_CLANG_VERSION" ] |
62682a34 SL |
1017 | then |
1018 | case $CFG_OSX_CLANG_VERSION in | |
1019 | (7.0*) | |
1020 | step_msg "found ok version of APPLE CLANG: $CFG_OSX_CLANG_VERSION" | |
1021 | ;; | |
1022 | (*) | |
1023 | err "bad APPLE CLANG version: $CFG_OSX_CLANG_VERSION, need >=7.0" | |
1024 | ;; | |
1025 | esac | |
1026 | else | |
1027 | case $CFG_CLANG_VERSION in | |
1028 | (3.2* | 3.3* | 3.4* | 3.5* | 3.6* | 3.7*) | |
1029 | step_msg "found ok version of CLANG: $CFG_CLANG_VERSION" | |
1030 | ;; | |
1031 | (*) | |
1032 | err "bad CLANG version: $CFG_CLANG_VERSION, need >=3.0svn" | |
1033 | ;; | |
1034 | esac | |
1035 | fi | |
1036 | ||
1037 | if [ -z "$CC" ] | |
1038 | then | |
1039 | CFG_CC="clang" | |
1040 | CFG_CXX="clang++" | |
1041 | fi | |
1042 | esac | |
223e47cc LB |
1043 | fi |
1044 | ||
c1a9b12d | 1045 | if [ -n "$CFG_ENABLE_CCACHE" ] |
970d7e83 | 1046 | then |
c1a9b12d | 1047 | if [ -z "$CFG_CCACHE" ] |
970d7e83 | 1048 | then |
c1a9b12d | 1049 | err "ccache requested but not found" |
970d7e83 | 1050 | fi |
c1a9b12d SL |
1051 | |
1052 | CFG_CC="ccache $CFG_CC" | |
1a4d82fc | 1053 | fi |
970d7e83 | 1054 | |
1a4d82fc JJ |
1055 | if [ -z "$CC" -a -z "$CFG_ENABLE_CLANG" -a -z "$CFG_GCC" ] |
1056 | then | |
1057 | err "either clang or gcc is required" | |
970d7e83 LB |
1058 | fi |
1059 | ||
1a4d82fc JJ |
1060 | # All safeguards based on $CFG_ENABLE_CLANG should occur before this |
1061 | # point in the script; after this point, script logic should inspect | |
1062 | # $CFG_USING_CLANG rather than $CFG_ENABLE_CLANG. | |
1063 | ||
1064 | # Set CFG_{CC,CXX,CPP,CFLAGS,CXXFLAGS} | |
1065 | envopt CC | |
1066 | envopt CXX | |
1067 | envopt CPP | |
1068 | envopt CFLAGS | |
1069 | envopt CXXFLAGS | |
223e47cc | 1070 | |
1a4d82fc | 1071 | # a little post-processing of various config values |
223e47cc | 1072 | CFG_PREFIX=${CFG_PREFIX%/} |
1a4d82fc JJ |
1073 | CFG_MANDIR=${CFG_MANDIR%/} |
1074 | CFG_HOST="$(echo $CFG_HOST | tr ',' ' ')" | |
1075 | CFG_TARGET="$(echo $CFG_TARGET | tr ',' ' ')" | |
1076 | CFG_SUPPORTED_TARGET="" | |
1077 | for target_file in ${CFG_SRC_DIR}mk/cfg/*.mk; do | |
1078 | CFG_SUPPORTED_TARGET="${CFG_SUPPORTED_TARGET} $(basename "$target_file" .mk)" | |
1079 | done | |
223e47cc | 1080 | |
c1a9b12d SL |
1081 | # copy build-triples to host-triples so that builds are a subset of hosts |
1082 | V_TEMP="" | |
1083 | for i in $CFG_BUILD $CFG_HOST; | |
1084 | do | |
1085 | echo "$V_TEMP" | grep -qF $i || V_TEMP="$V_TEMP${V_TEMP:+ }$i" | |
1086 | done | |
1087 | CFG_HOST=$V_TEMP | |
1088 | ||
223e47cc LB |
1089 | # copy host-triples to target-triples so that hosts are a subset of targets |
1090 | V_TEMP="" | |
1a4d82fc | 1091 | for i in $CFG_HOST $CFG_TARGET; |
223e47cc LB |
1092 | do |
1093 | echo "$V_TEMP" | grep -qF $i || V_TEMP="$V_TEMP${V_TEMP:+ }$i" | |
1094 | done | |
1a4d82fc | 1095 | CFG_TARGET=$V_TEMP |
223e47cc LB |
1096 | |
1097 | # check target-specific tool-chains | |
1a4d82fc | 1098 | for i in $CFG_TARGET |
223e47cc LB |
1099 | do |
1100 | L_CHECK=false | |
1a4d82fc | 1101 | for j in $CFG_SUPPORTED_TARGET |
223e47cc LB |
1102 | do |
1103 | if [ $i = $j ] | |
1104 | then | |
1105 | L_CHECK=true | |
1106 | fi | |
1107 | done | |
1108 | ||
1109 | if [ $L_CHECK = false ] | |
1110 | then | |
1111 | err "unsupported target triples \"$i\" found" | |
1112 | fi | |
1113 | ||
1114 | case $i in | |
c1a9b12d SL |
1115 | *android*) |
1116 | upper_snake_target=$(echo "$i" | tr '[:lower:]' '[:upper:]' | tr '\-' '\_') | |
1117 | eval ndk=\$"CFG_${upper_snake_target}_NDK" | |
1118 | if [ -z "$ndk" ] | |
223e47cc | 1119 | then |
c1a9b12d SL |
1120 | ndk=$CFG_ANDROID_CROSS_PATH |
1121 | eval "CFG_${upper_snake_target}_NDK"=$CFG_ANDROID_CROSS_PATH | |
1122 | warn "generic/default Android NDK option is deprecated (use --$i-ndk option instead)" | |
223e47cc | 1123 | fi |
c1a9b12d SL |
1124 | |
1125 | # Perform a basic sanity check of the NDK | |
1126 | for android_ndk_tool in "$ndk/bin/$i-gcc" "$ndk/bin/$i-g++" "$ndk/bin/$i-ar" | |
1127 | do | |
1128 | if [ ! -f $android_ndk_tool ] | |
1129 | then | |
1130 | err "NDK tool $android_ndk_tool not found (bad or missing --$i-ndk option?)" | |
1131 | fi | |
1132 | done | |
223e47cc LB |
1133 | ;; |
1134 | ||
1a4d82fc JJ |
1135 | arm-apple-darwin) |
1136 | if [ $CFG_OSTYPE != apple-darwin ] | |
1137 | then | |
1138 | err "The iOS target is only supported on Mac OS X" | |
1139 | fi | |
1140 | ;; | |
1141 | ||
d9579d0f AL |
1142 | |
1143 | *-musl) | |
1144 | if [ ! -f $CFG_MUSL_ROOT/lib/libc.a ] | |
1145 | then | |
1146 | err "musl libc $CFG_MUSL_ROOT/lib/libc.a not found" | |
1147 | fi | |
1148 | ;; | |
62682a34 | 1149 | |
c1a9b12d | 1150 | *-msvc) |
62682a34 SL |
1151 | # Currently the build system is not configured to build jemalloc |
1152 | # with MSVC, so we omit this optional dependency. | |
1153 | step_msg "targeting MSVC, disabling jemalloc" | |
1154 | CFG_DISABLE_JEMALLOC=1 | |
1155 | putvar CFG_DISABLE_JEMALLOC | |
1156 | ||
1157 | # There are some MSYS python builds which will auto-translate | |
1158 | # windows-style paths to MSYS-style paths in Python itself. | |
1159 | # Unfortunately this breaks LLVM's build system as somewhere along | |
1160 | # the line LLVM prints a path into a file from Python and then CMake | |
1161 | # later tries to interpret that path. If Python prints a MSYS path | |
1162 | # and CMake tries to use it as a Windows path, you're gonna have a | |
1163 | # Bad Time. | |
1164 | # | |
1165 | # Consequently here we try to detect when that happens and print an | |
1166 | # error if it does. | |
1167 | if $CFG_PYTHON -c 'import sys; print sys.argv[1]' `pwd` | grep '^/' | |
1168 | then | |
1169 | err "python is silently translating windows paths to MSYS paths \ | |
1170 | and the build will fail if this python is used.\n\n \ | |
1171 | Either an official python install must be used or an \ | |
1172 | alternative python package in MinGW must be used." | |
1173 | fi | |
1174 | ||
1175 | # MSVC requires cmake because that's how we're going to build LLVM | |
1176 | probe_need CFG_CMAKE cmake | |
1177 | ||
1178 | # Use the REG program to figure out where VS is installed | |
1179 | # We need to figure out where cl.exe and link.exe are, so we do some | |
1180 | # munging and some probing here. We also look for the default | |
1181 | # INCLUDE and LIB variables for MSVC so we can set those in the | |
1182 | # build system as well. | |
1183 | install=$(reg QUERY \ | |
c1a9b12d | 1184 | 'HKLM\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\14.0' \ |
62682a34 | 1185 | -v InstallDir) |
c1a9b12d SL |
1186 | if [ -z "$install" ]; then |
1187 | install=$(reg QUERY \ | |
1188 | 'HKLM\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\12.0' \ | |
1189 | -v InstallDir) | |
1190 | fi | |
62682a34 SL |
1191 | need_ok "couldn't find visual studio install root" |
1192 | CFG_MSVC_ROOT=$(echo "$install" | grep InstallDir | sed 's/.*REG_SZ[ ]*//') | |
1193 | CFG_MSVC_ROOT=$(dirname "$CFG_MSVC_ROOT") | |
1194 | CFG_MSVC_ROOT=$(dirname "$CFG_MSVC_ROOT") | |
c1a9b12d SL |
1195 | putvar CFG_MSVC_ROOT |
1196 | ||
1197 | case $i in | |
1198 | x86_64-*) | |
1199 | bits=x86_64 | |
1200 | msvc_part=amd64 | |
1201 | ;; | |
1202 | i686-*) | |
1203 | bits=i386 | |
1204 | msvc_part= | |
1205 | ;; | |
1206 | *) | |
1207 | err "can only target x86 targets for MSVC" | |
1208 | ;; | |
1209 | esac | |
1210 | bindir="${CFG_MSVC_ROOT}/VC/bin" | |
1211 | if [ -n "$msvc_part" ]; then | |
1212 | bindir="$bindir/$msvc_part" | |
1213 | fi | |
1214 | eval CFG_MSVC_BINDIR_$bits="\"$bindir\"" | |
1215 | eval CFG_MSVC_CL_$bits="\"$bindir/cl.exe\"" | |
1216 | eval CFG_MSVC_LIB_$bits="\"$bindir/lib.exe\"" | |
1217 | eval CFG_MSVC_LINK_$bits="\"$bindir/link.exe\"" | |
62682a34 SL |
1218 | |
1219 | vcvarsall="${CFG_MSVC_ROOT}/VC/vcvarsall.bat" | |
c1a9b12d | 1220 | include_path=$(cmd /c "\"$vcvarsall\" $msvc_part && cmd /c echo %INCLUDE%") |
62682a34 | 1221 | need_ok "failed to learn about MSVC's INCLUDE" |
c1a9b12d | 1222 | lib_path=$(cmd /c "\"$vcvarsall\" $msvc_part && cmd /c echo %LIB%") |
62682a34 SL |
1223 | need_ok "failed to learn about MSVC's LIB" |
1224 | ||
c1a9b12d SL |
1225 | eval CFG_MSVC_INCLUDE_PATH_${bits}="\"$include_path\"" |
1226 | eval CFG_MSVC_LIB_PATH_${bits}="\"$lib_path\"" | |
1227 | ||
1228 | putvar CFG_MSVC_BINDIR_${bits} | |
1229 | putvar CFG_MSVC_CL_${bits} | |
1230 | putvar CFG_MSVC_LIB_${bits} | |
1231 | putvar CFG_MSVC_LINK_${bits} | |
1232 | putvar CFG_MSVC_INCLUDE_PATH_${bits} | |
1233 | putvar CFG_MSVC_LIB_PATH_${bits} | |
62682a34 SL |
1234 | ;; |
1235 | ||
223e47cc LB |
1236 | *) |
1237 | ;; | |
1238 | esac | |
1239 | done | |
1240 | ||
c1a9b12d | 1241 | if [ -n "$CFG_PERF" ] |
223e47cc LB |
1242 | then |
1243 | HAVE_PERF_LOGFD=`$CFG_PERF stat --log-fd 2>&1 | grep 'unknown option'` | |
1244 | if [ -z "$HAVE_PERF_LOGFD" ]; | |
1245 | then | |
1246 | CFG_PERF_WITH_LOGFD=1 | |
1247 | putvar CFG_PERF_WITH_LOGFD | |
1248 | fi | |
1249 | fi | |
1250 | ||
1251 | step_msg "making directories" | |
1252 | ||
1253 | for i in \ | |
970d7e83 | 1254 | doc doc/std doc/extra \ |
1a4d82fc | 1255 | dl tmp dist |
223e47cc LB |
1256 | do |
1257 | make_dir $i | |
1258 | done | |
1259 | ||
1a4d82fc | 1260 | for t in $CFG_HOST |
223e47cc | 1261 | do |
1a4d82fc | 1262 | make_dir $t/llvm |
223e47cc LB |
1263 | done |
1264 | ||
1a4d82fc | 1265 | for t in $CFG_HOST |
223e47cc | 1266 | do |
1a4d82fc | 1267 | make_dir $t/rustllvm |
223e47cc LB |
1268 | done |
1269 | ||
1a4d82fc | 1270 | for t in $CFG_TARGET |
223e47cc | 1271 | do |
1a4d82fc | 1272 | make_dir $t/rt |
970d7e83 | 1273 | for s in 0 1 2 3 |
223e47cc | 1274 | do |
1a4d82fc JJ |
1275 | make_dir $t/rt/stage$s |
1276 | make_dir $t/rt/jemalloc | |
62682a34 | 1277 | make_dir $t/rt/compiler-rt |
970d7e83 | 1278 | for i in \ |
1a4d82fc | 1279 | isaac sync test \ |
85aaf69f | 1280 | arch/i386 arch/x86_64 arch/arm arch/aarch64 arch/mips arch/powerpc |
970d7e83 | 1281 | do |
1a4d82fc | 1282 | make_dir $t/rt/stage$s/$i |
970d7e83 | 1283 | done |
223e47cc LB |
1284 | done |
1285 | done | |
1286 | ||
1a4d82fc | 1287 | for h in $CFG_HOST |
223e47cc | 1288 | do |
1a4d82fc | 1289 | for t in $CFG_TARGET |
223e47cc | 1290 | do |
1a4d82fc JJ |
1291 | # host lib dir stage0 |
1292 | make_dir $h/stage0/lib | |
1293 | ||
1294 | # target bin dir stage0 | |
1295 | make_dir $h/stage0/lib/rustlib/$t/bin | |
1296 | ||
1297 | # target lib dir stage0 | |
1298 | make_dir $h/stage0/lib/rustlib/$t/lib | |
1299 | ||
223e47cc LB |
1300 | for i in 0 1 2 3 |
1301 | do | |
1302 | # host bin dir | |
1303 | make_dir $h/stage$i/bin | |
1304 | ||
1305 | # host lib dir | |
1a4d82fc | 1306 | make_dir $h/stage$i/$CFG_LIBDIR_RELATIVE |
223e47cc | 1307 | |
970d7e83 LB |
1308 | # host test dir |
1309 | make_dir $h/stage$i/test | |
1310 | ||
223e47cc | 1311 | # target bin dir |
1a4d82fc | 1312 | make_dir $h/stage$i/$CFG_LIBDIR_RELATIVE/rustlib/$t/bin |
223e47cc LB |
1313 | |
1314 | # target lib dir | |
1a4d82fc | 1315 | make_dir $h/stage$i/$CFG_LIBDIR_RELATIVE/rustlib/$t/lib |
223e47cc LB |
1316 | done |
1317 | done | |
1318 | ||
1319 | make_dir $h/test/run-pass | |
1a4d82fc | 1320 | make_dir $h/test/run-pass-valgrind |
223e47cc LB |
1321 | make_dir $h/test/run-pass-fulldeps |
1322 | make_dir $h/test/run-fail | |
d9579d0f | 1323 | make_dir $h/test/run-fail-fulldeps |
223e47cc | 1324 | make_dir $h/test/compile-fail |
85aaf69f | 1325 | make_dir $h/test/parse-fail |
1a4d82fc | 1326 | make_dir $h/test/compile-fail-fulldeps |
223e47cc LB |
1327 | make_dir $h/test/bench |
1328 | make_dir $h/test/perf | |
1329 | make_dir $h/test/pretty | |
1a4d82fc JJ |
1330 | make_dir $h/test/debuginfo-gdb |
1331 | make_dir $h/test/debuginfo-lldb | |
1332 | make_dir $h/test/codegen | |
9346a6ac | 1333 | make_dir $h/test/rustdoc |
223e47cc LB |
1334 | done |
1335 | ||
1336 | # Configure submodules | |
1337 | step_msg "configuring submodules" | |
1338 | ||
1339 | # Have to be in the top of src directory for this | |
1340 | if [ -z $CFG_DISABLE_MANAGE_SUBMODULES ] | |
1341 | then | |
1342 | cd ${CFG_SRC_DIR} | |
1343 | ||
1344 | msg "git: submodule sync" | |
1a4d82fc JJ |
1345 | "${CFG_GIT}" submodule sync |
1346 | ||
1347 | msg "git: submodule init" | |
1348 | "${CFG_GIT}" submodule init | |
1349 | ||
1350 | # Disable submodules that we're not using | |
c1a9b12d | 1351 | if [ -n "${CFG_LLVM_ROOT}" ]; then |
1a4d82fc JJ |
1352 | msg "git: submodule deinit src/llvm" |
1353 | "${CFG_GIT}" submodule deinit src/llvm | |
1354 | fi | |
c1a9b12d | 1355 | if [ -n "${CFG_JEMALLOC_ROOT}" ]; then |
1a4d82fc JJ |
1356 | msg "git: submodule deinit src/jemalloc" |
1357 | "${CFG_GIT}" submodule deinit src/jemalloc | |
1358 | fi | |
223e47cc LB |
1359 | |
1360 | msg "git: submodule update" | |
1a4d82fc | 1361 | "${CFG_GIT}" submodule update |
223e47cc LB |
1362 | need_ok "git failed" |
1363 | ||
1364 | msg "git: submodule foreach sync" | |
1a4d82fc | 1365 | "${CFG_GIT}" submodule foreach --recursive 'if test -e .gitmodules; then git submodule sync; fi' |
223e47cc LB |
1366 | need_ok "git failed" |
1367 | ||
1368 | msg "git: submodule foreach update" | |
1a4d82fc | 1369 | "${CFG_GIT}" submodule update --recursive |
223e47cc LB |
1370 | need_ok "git failed" |
1371 | ||
1372 | # NB: this is just for the sake of getting the submodule SHA1 values | |
1373 | # and status written into the build log. | |
1374 | msg "git: submodule status" | |
1375 | "${CFG_GIT}" submodule status --recursive | |
1376 | ||
1377 | msg "git: submodule clobber" | |
1a4d82fc | 1378 | "${CFG_GIT}" submodule foreach --recursive git clean -dxf |
223e47cc | 1379 | need_ok "git failed" |
1a4d82fc | 1380 | "${CFG_GIT}" submodule foreach --recursive git checkout . |
223e47cc LB |
1381 | need_ok "git failed" |
1382 | ||
1383 | cd ${CFG_BUILD_DIR} | |
1384 | fi | |
1385 | ||
1386 | # Configure llvm, only if necessary | |
1387 | step_msg "looking at LLVM" | |
1388 | CFG_LLVM_SRC_DIR=${CFG_SRC_DIR}src/llvm/ | |
1a4d82fc | 1389 | for t in $CFG_HOST |
223e47cc LB |
1390 | do |
1391 | do_reconfigure=1 | |
62682a34 SL |
1392 | is_msvc=0 |
1393 | case "$t" in | |
1394 | (*-msvc) | |
1395 | is_msvc=1 | |
1396 | ;; | |
1397 | esac | |
223e47cc LB |
1398 | |
1399 | if [ -z $CFG_LLVM_ROOT ] | |
1400 | then | |
1a4d82fc | 1401 | LLVM_BUILD_DIR=${CFG_BUILD_DIR}$t/llvm |
c1a9b12d | 1402 | if [ -n "$CFG_DISABLE_OPTIMIZE_LLVM" ] |
223e47cc LB |
1403 | then |
1404 | LLVM_DBG_OPTS="--enable-debug-symbols --disable-optimized" | |
1405 | # Just use LLVM straight from its build directory to | |
1406 | # avoid 'make install' time | |
1a4d82fc | 1407 | LLVM_INST_DIR=$LLVM_BUILD_DIR/Debug |
223e47cc LB |
1408 | else |
1409 | LLVM_DBG_OPTS="--enable-optimized" | |
1a4d82fc JJ |
1410 | LLVM_INST_DIR=$LLVM_BUILD_DIR/Release |
1411 | fi | |
9346a6ac | 1412 | if [ -z "$CFG_ENABLE_LLVM_ASSERTIONS" ] |
1a4d82fc JJ |
1413 | then |
1414 | LLVM_ASSERTION_OPTS="--disable-assertions" | |
1415 | else | |
1416 | LLVM_ASSERTION_OPTS="--enable-assertions" | |
62682a34 SL |
1417 | |
1418 | # Apparently even if we request assertions be enabled for MSVC, | |
1419 | # LLVM's CMake build system ignore this and outputs in `Release` | |
1420 | # anyway. | |
1421 | if [ ${is_msvc} -eq 0 ]; then | |
1422 | LLVM_INST_DIR=${LLVM_INST_DIR}+Asserts | |
1423 | fi | |
223e47cc LB |
1424 | fi |
1425 | else | |
1426 | msg "not reconfiguring LLVM, external LLVM root" | |
1427 | # The user is using their own LLVM | |
1428 | LLVM_BUILD_DIR= | |
1429 | LLVM_INST_DIR=$CFG_LLVM_ROOT | |
1430 | do_reconfigure=0 | |
1431 | fi | |
1432 | ||
1433 | ||
1434 | if [ ${do_reconfigure} -ne 0 ] | |
1435 | then | |
1436 | # because git is hilarious, it might have put the module index | |
1437 | # in a couple places. | |
1438 | index1="${CFG_SRC_DIR}.git/modules/src/llvm/index" | |
1439 | index2="${CFG_SRC_DIR}src/llvm/.git/index" | |
1440 | for index in ${index1} ${index2} | |
1441 | do | |
1a4d82fc | 1442 | config_status="${LLVM_BUILD_DIR}/config.status" |
223e47cc LB |
1443 | if test -e ${index} -a \ |
1444 | -e ${config_status} -a \ | |
1445 | ${config_status} -nt ${index} | |
1446 | then | |
1447 | msg "not reconfiguring LLVM, config.status is fresh" | |
1448 | do_reconfigure=0 | |
1449 | fi | |
1450 | done | |
1451 | fi | |
1452 | ||
62682a34 SL |
1453 | if [ ${do_reconfigure} -ne 0 ] && [ ${is_msvc} -ne 0 ] |
1454 | then | |
1455 | msg "configuring LLVM for $t with cmake" | |
1456 | ||
1457 | CMAKE_ARGS="-DLLVM_INCLUDE_TESTS=OFF" | |
c1a9b12d | 1458 | if [ -n "$CFG_DISABLE_OPTIMIZE_LLVM" ]; then |
62682a34 SL |
1459 | CMAKE_ARGS="$CMAKE_ARGS -DCMAKE_BUILD_TYPE=Debug" |
1460 | else | |
1461 | CMAKE_ARGS="$CMAKE_ARGS -DCMAKE_BUILD_TYPE=Release" | |
1462 | fi | |
1463 | if [ -z "$CFG_ENABLE_LLVM_ASSERTIONS" ] | |
1464 | then | |
1465 | CMAKE_ARGS="$CMAKE_ARGS -DLLVM_ENABLE_ASSERTIONS=OFF" | |
1466 | else | |
1467 | CMAKE_ARGS="$CMAKE_ARGS -DLLVM_ENABLE_ASSERTIONS=ON" | |
1468 | fi | |
1469 | ||
1470 | msg "configuring LLVM with:" | |
1471 | msg "$CMAKE_ARGS" | |
c1a9b12d SL |
1472 | case "$CFG_MSVC_ROOT" in |
1473 | *14.0*) | |
1474 | generator="Visual Studio 14 2015" | |
1475 | ;; | |
1476 | *12.0*) | |
1477 | generator="Visual Studio 12 2013" | |
1478 | ;; | |
1479 | *) | |
1480 | err "can't determine generator for LLVM cmake" | |
1481 | ;; | |
1482 | esac | |
1483 | case "$t" in | |
1484 | x86_64-*) | |
1485 | generator="$generator Win64" | |
1486 | ;; | |
1487 | i686-*) | |
1488 | ;; | |
1489 | *) | |
1490 | err "can only build LLVM for x86 platforms" | |
1491 | ;; | |
1492 | esac | |
62682a34 | 1493 | (cd $LLVM_BUILD_DIR && "$CFG_CMAKE" $CFG_LLVM_SRC_DIR \ |
c1a9b12d | 1494 | -G "$generator" \ |
62682a34 SL |
1495 | $CMAKE_ARGS) |
1496 | need_ok "LLVM cmake configure failed" | |
1497 | fi | |
1498 | ||
1499 | if [ ${do_reconfigure} -ne 0 ] && [ ${is_msvc} -eq 0 ] | |
223e47cc | 1500 | then |
1a4d82fc JJ |
1501 | # LLVM's configure doesn't recognize the new Windows triples yet |
1502 | gnu_t=$(to_gnu_triple $t) | |
1503 | ||
1504 | msg "configuring LLVM for $gnu_t" | |
223e47cc | 1505 | |
85aaf69f | 1506 | LLVM_TARGETS="--enable-targets=x86,x86_64,arm,aarch64,mips,powerpc" |
1a4d82fc JJ |
1507 | LLVM_BUILD="--build=$gnu_t" |
1508 | LLVM_HOST="--host=$gnu_t" | |
1509 | LLVM_TARGET="--target=$gnu_t" | |
223e47cc LB |
1510 | |
1511 | # Disable unused LLVM features | |
1a4d82fc JJ |
1512 | LLVM_OPTS="$LLVM_DBG_OPTS $LLVM_ASSERTION_OPTS --disable-docs --enable-bindings=none" |
1513 | # Disable term-info, linkage of which comes in multiple forms, | |
1514 | # making our snapshots incompatible (#9334) | |
1515 | LLVM_OPTS="$LLVM_OPTS --disable-terminfo" | |
1516 | # Try to have LLVM pull in as few dependencies as possible (#9397) | |
1517 | LLVM_OPTS="$LLVM_OPTS --disable-zlib --disable-libffi" | |
1518 | ||
1519 | # Use win32 native thread/lock apis instead of pthread wrapper. | |
1520 | # (llvm's configure tries to find pthread first, so we have to disable it explicitly.) | |
1521 | # Also note that pthreads works badly on mingw-w64 systems: #8996 | |
1522 | case "$CFG_BUILD" in | |
62682a34 | 1523 | (*-windows-gnu) |
1a4d82fc JJ |
1524 | LLVM_OPTS="$LLVM_OPTS --disable-pthreads" |
1525 | ;; | |
1526 | esac | |
223e47cc | 1527 | |
1a4d82fc | 1528 | case "$CFG_CC" in |
970d7e83 | 1529 | ("ccache clang") |
1a4d82fc JJ |
1530 | LLVM_CXX_32="ccache clang++ -Qunused-arguments" |
1531 | LLVM_CC_32="ccache clang -Qunused-arguments" | |
970d7e83 LB |
1532 | |
1533 | LLVM_CXX_64="ccache clang++ -Qunused-arguments" | |
1534 | LLVM_CC_64="ccache clang -Qunused-arguments" | |
1535 | ;; | |
1536 | ("clang") | |
1a4d82fc JJ |
1537 | LLVM_CXX_32="clang++ -Qunused-arguments" |
1538 | LLVM_CC_32="clang -Qunused-arguments" | |
223e47cc | 1539 | |
1a4d82fc JJ |
1540 | LLVM_CXX_64="clang++ -Qunused-arguments" |
1541 | LLVM_CC_64="clang -Qunused-arguments" | |
970d7e83 LB |
1542 | ;; |
1543 | ("ccache gcc") | |
1a4d82fc JJ |
1544 | LLVM_CXX_32="ccache g++" |
1545 | LLVM_CC_32="ccache gcc" | |
970d7e83 LB |
1546 | |
1547 | LLVM_CXX_64="ccache g++" | |
1548 | LLVM_CC_64="ccache gcc" | |
1549 | ;; | |
1550 | ("gcc") | |
1a4d82fc JJ |
1551 | LLVM_CXX_32="g++" |
1552 | LLVM_CC_32="gcc" | |
223e47cc LB |
1553 | |
1554 | LLVM_CXX_64="g++" | |
1555 | LLVM_CC_64="gcc" | |
1a4d82fc JJ |
1556 | ;; |
1557 | ||
1558 | (*) | |
1559 | msg "inferring LLVM_CXX/CC from CXX/CC = $CXX/$CC" | |
c1a9b12d SL |
1560 | if [ -n "$CFG_ENABLE_CCACHE" ] |
1561 | then | |
1562 | if [ -z "$CFG_CCACHE" ] | |
1563 | then | |
1564 | err "ccache requested but not found" | |
1565 | fi | |
1566 | ||
1567 | LLVM_CXX_32="ccache $CXX" | |
1568 | LLVM_CC_32="ccache $CC" | |
1569 | ||
1570 | LLVM_CXX_64="ccache $CXX" | |
1571 | LLVM_CC_64="ccache $CC" | |
1572 | else | |
1573 | LLVM_CXX_32="$CXX" | |
1574 | LLVM_CC_32="$CC" | |
1575 | ||
1576 | LLVM_CXX_64="$CXX" | |
1577 | LLVM_CC_64="$CC" | |
1578 | fi | |
1a4d82fc | 1579 | |
1a4d82fc | 1580 | ;; |
970d7e83 | 1581 | esac |
223e47cc | 1582 | |
1a4d82fc JJ |
1583 | case "$CFG_CPUTYPE" in |
1584 | (x86*) | |
1585 | LLVM_CXX_32="$LLVM_CXX_32 -m32" | |
1586 | LLVM_CC_32="$LLVM_CC_32 -m32" | |
1587 | ||
1588 | LLVM_CFLAGS_32="-m32" | |
1589 | LLVM_CXXFLAGS_32="-m32" | |
1590 | LLVM_LDFLAGS_32="-m32" | |
223e47cc | 1591 | |
1a4d82fc JJ |
1592 | LLVM_CFLAGS_64="" |
1593 | LLVM_CXXFLAGS_64="" | |
1594 | LLVM_LDFLAGS_64="" | |
1595 | ||
1596 | LLVM_CXX_32="$LLVM_CXX_32 -m32" | |
1597 | LLVM_CC_32="$LLVM_CC_32 -m32" | |
1598 | ;; | |
1599 | ||
1600 | (*) | |
1601 | LLVM_CFLAGS_32="" | |
1602 | LLVM_CXXFLAGS_32="" | |
1603 | LLVM_LDFLAGS_32="" | |
1604 | ||
1605 | LLVM_CFLAGS_64="" | |
1606 | LLVM_CXXFLAGS_64="" | |
1607 | LLVM_LDFLAGS_64="" | |
1608 | ;; | |
1609 | esac | |
223e47cc LB |
1610 | |
1611 | if echo $t | grep -q x86_64 | |
1612 | then | |
1613 | LLVM_CXX=$LLVM_CXX_64 | |
1614 | LLVM_CC=$LLVM_CC_64 | |
1615 | LLVM_CFLAGS=$LLVM_CFLAGS_64 | |
1616 | LLVM_CXXFLAGS=$LLVM_CXXFLAGS_64 | |
1617 | LLVM_LDFLAGS=$LLVM_LDFLAGS_64 | |
1618 | else | |
1619 | LLVM_CXX=$LLVM_CXX_32 | |
1620 | LLVM_CC=$LLVM_CC_32 | |
1621 | LLVM_CFLAGS=$LLVM_CFLAGS_32 | |
1622 | LLVM_CXXFLAGS=$LLVM_CXXFLAGS_32 | |
1623 | LLVM_LDFLAGS=$LLVM_LDFLAGS_32 | |
1624 | fi | |
1625 | ||
1626 | CXX=$LLVM_CXX | |
1627 | CC=$LLVM_CC | |
1628 | CFLAGS=$LLVM_CFLAGS | |
1629 | CXXFLAGS=$LLVM_CXXFLAGS | |
1630 | LDFLAGS=$LLVM_LDFLAGS | |
1631 | ||
1a4d82fc JJ |
1632 | if [ -z "$CFG_DISABLE_LIBCPP" ] && [ -n "$CFG_USING_CLANG" ]; then |
1633 | LLVM_OPTS="$LLVM_OPTS --enable-libcpp" | |
1634 | fi | |
1635 | ||
223e47cc | 1636 | LLVM_FLAGS="$LLVM_TARGETS $LLVM_OPTS $LLVM_BUILD \ |
970d7e83 | 1637 | $LLVM_HOST $LLVM_TARGET --with-python=$CFG_PYTHON" |
223e47cc LB |
1638 | |
1639 | msg "configuring LLVM with:" | |
1640 | msg "$LLVM_FLAGS" | |
1641 | ||
1642 | export CXX | |
1643 | export CC | |
1644 | export CFLAGS | |
1645 | export CXXFLAGS | |
1646 | export LDFLAGS | |
1647 | ||
1648 | cd $LLVM_BUILD_DIR | |
1649 | case $CFG_SRC_DIR in | |
1650 | /* | [a-z]:* | [A-Z]:*) | |
1651 | ${CFG_LLVM_SRC_DIR}configure $LLVM_FLAGS | |
1652 | ;; | |
1653 | *) | |
1654 | ${CFG_BUILD_DIR}${CFG_LLVM_SRC_DIR}configure \ | |
1655 | $LLVM_FLAGS | |
1656 | ;; | |
1657 | esac | |
1658 | need_ok "LLVM configure failed" | |
1659 | ||
223e47cc LB |
1660 | cd $CFG_BUILD_DIR |
1661 | fi | |
1662 | ||
1663 | # Construct variables for LLVM build and install directories for | |
1664 | # each target. These will be named | |
1665 | # CFG_LLVM_BUILD_DIR_${target_triple} but all the hyphens in | |
1666 | # target_triple will be converted to underscore, because bash | |
1667 | # variables can't contain hyphens. The makefile will then have to | |
1668 | # convert back. | |
1669 | CFG_LLVM_BUILD_DIR=$(echo CFG_LLVM_BUILD_DIR_${t} | tr - _) | |
1670 | CFG_LLVM_INST_DIR=$(echo CFG_LLVM_INST_DIR_${t} | tr - _) | |
1671 | eval ${CFG_LLVM_BUILD_DIR}="'$LLVM_BUILD_DIR'" | |
1672 | eval ${CFG_LLVM_INST_DIR}="'$LLVM_INST_DIR'" | |
1673 | done | |
1674 | ||
1675 | ||
1676 | step_msg "writing configuration" | |
1677 | ||
1678 | putvar CFG_SRC_DIR | |
62682a34 | 1679 | putvar CFG_SRC_DIR_RELATIVE |
223e47cc LB |
1680 | putvar CFG_BUILD_DIR |
1681 | putvar CFG_OSTYPE | |
1682 | putvar CFG_CPUTYPE | |
1683 | putvar CFG_CONFIGURE_ARGS | |
1684 | putvar CFG_PREFIX | |
1a4d82fc JJ |
1685 | putvar CFG_HOST |
1686 | putvar CFG_TARGET | |
1687 | putvar CFG_LIBDIR_RELATIVE | |
223e47cc | 1688 | putvar CFG_DISABLE_MANAGE_SUBMODULES |
c1a9b12d SL |
1689 | putvar CFG_AARCH64_LINUX_ANDROID_NDK |
1690 | putvar CFG_ARM_LINUX_ANDROIDEABI_NDK | |
1a4d82fc | 1691 | putvar CFG_MANDIR |
223e47cc | 1692 | |
970d7e83 LB |
1693 | # Avoid spurious warnings from clang by feeding it original source on |
1694 | # ccache-miss rather than preprocessed input. | |
c1a9b12d | 1695 | if [ -n "$CFG_ENABLE_CCACHE" ] && [ -n "$CFG_USING_CLANG" ] |
970d7e83 LB |
1696 | then |
1697 | CFG_CCACHE_CPP2=1 | |
1698 | putvar CFG_CCACHE_CPP2 | |
1699 | fi | |
1700 | ||
c1a9b12d | 1701 | if [ -n "$CFG_ENABLE_CCACHE" ] |
970d7e83 LB |
1702 | then |
1703 | CFG_CCACHE_BASEDIR=${CFG_SRC_DIR} | |
1704 | putvar CFG_CCACHE_BASEDIR | |
1705 | fi | |
1706 | ||
1707 | ||
c1a9b12d | 1708 | if [ -n $BAD_PANDOC ] |
223e47cc LB |
1709 | then |
1710 | CFG_PANDOC= | |
1711 | putvar CFG_PANDOC | |
1712 | fi | |
1713 | ||
223e47cc LB |
1714 | putvar CFG_LLVM_SRC_DIR |
1715 | ||
1a4d82fc | 1716 | for t in $CFG_HOST |
223e47cc LB |
1717 | do |
1718 | CFG_LLVM_BUILD_DIR=$(echo CFG_LLVM_BUILD_DIR_${t} | tr - _) | |
1719 | CFG_LLVM_INST_DIR=$(echo CFG_LLVM_INST_DIR_${t} | tr - _) | |
1720 | putvar $CFG_LLVM_BUILD_DIR | |
1721 | putvar $CFG_LLVM_INST_DIR | |
1722 | done | |
1723 | ||
223e47cc LB |
1724 | msg |
1725 | copy_if_changed ${CFG_SRC_DIR}Makefile.in ./Makefile | |
1726 | move_if_changed config.tmp config.mk | |
1727 | rm -f config.tmp | |
1728 | touch config.stamp | |
1729 | ||
9346a6ac AL |
1730 | if [ -z "$CFG_ENABLE_DEBUG" ]; then |
1731 | step_msg "configured in release mode. for development consider --enable-debug" | |
1732 | else | |
1733 | step_msg "complete" | |
1734 | fi | |
1735 | ||
1a4d82fc JJ |
1736 | msg "run \`make help\`" |
1737 | msg |