]>
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 | |
286 | if [ ! -z "$META" ] | |
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. | |
320 | if [ ! -z "$VV" ] | |
321 | then | |
322 | putvar $V | |
323 | fi | |
324 | } | |
325 | ||
326 | to_llvm_triple() { | |
327 | case $1 in | |
328 | i686-w64-mingw32) echo i686-pc-windows-gnu ;; | |
329 | x86_64-w64-mingw32) echo x86_64-pc-windows-gnu ;; | |
330 | *) echo $1 ;; | |
331 | esac | |
332 | } | |
333 | ||
334 | to_gnu_triple() { | |
335 | case $1 in | |
336 | i686-pc-windows-gnu) echo i686-w64-mingw32 ;; | |
337 | x86_64-pc-windows-gnu) echo x86_64-w64-mingw32 ;; | |
338 | *) echo $1 ;; | |
339 | esac | |
340 | } | |
341 | ||
d9579d0f AL |
342 | # Prints the absolute path of a directory to stdout |
343 | abs_path() { | |
344 | local _path="$1" | |
345 | # Unset CDPATH because it causes havok: it makes the destination unpredictable | |
346 | # and triggers 'cd' to print the path to stdout. Route `cd`'s output to /dev/null | |
347 | # for good measure. | |
348 | (unset CDPATH && cd "$_path" > /dev/null && pwd) | |
349 | } | |
350 | ||
223e47cc LB |
351 | msg "looking for configure programs" |
352 | need_cmd cmp | |
353 | need_cmd mkdir | |
354 | need_cmd printf | |
355 | need_cmd cut | |
356 | need_cmd head | |
357 | need_cmd grep | |
358 | need_cmd xargs | |
359 | need_cmd cp | |
360 | need_cmd find | |
361 | need_cmd uname | |
362 | need_cmd date | |
363 | need_cmd tr | |
364 | need_cmd sed | |
970d7e83 | 365 | need_cmd file |
85aaf69f | 366 | need_cmd make |
223e47cc LB |
367 | |
368 | msg "inspecting environment" | |
369 | ||
370 | CFG_OSTYPE=$(uname -s) | |
371 | CFG_CPUTYPE=$(uname -m) | |
372 | ||
373 | if [ $CFG_OSTYPE = Darwin -a $CFG_CPUTYPE = i386 ] | |
374 | then | |
375 | # Darwin's `uname -s` lies and always returns i386. We have to use sysctl | |
376 | # instead. | |
377 | if sysctl hw.optional.x86_64 | grep -q ': 1' | |
378 | then | |
379 | CFG_CPUTYPE=x86_64 | |
380 | fi | |
381 | fi | |
382 | ||
383 | # The goal here is to come up with the same triple as LLVM would, | |
384 | # at least for the subset of platforms we're willing to target. | |
385 | ||
386 | case $CFG_OSTYPE in | |
387 | ||
388 | Linux) | |
389 | CFG_OSTYPE=unknown-linux-gnu | |
390 | ;; | |
391 | ||
392 | FreeBSD) | |
393 | CFG_OSTYPE=unknown-freebsd | |
394 | ;; | |
395 | ||
1a4d82fc JJ |
396 | DragonFly) |
397 | CFG_OSTYPE=unknown-dragonfly | |
398 | ;; | |
399 | ||
c34b1796 AL |
400 | Bitrig) |
401 | CFG_OSTYPE=unknown-bitrig | |
402 | ;; | |
403 | ||
85aaf69f | 404 | OpenBSD) |
c34b1796 | 405 | CFG_OSTYPE=unknown-openbsd |
85aaf69f SL |
406 | ;; |
407 | ||
223e47cc LB |
408 | Darwin) |
409 | CFG_OSTYPE=apple-darwin | |
410 | ;; | |
411 | ||
1a4d82fc JJ |
412 | MINGW*) |
413 | # msys' `uname` does not print gcc configuration, but prints msys | |
414 | # configuration. so we cannot believe `uname -m`: | |
415 | # msys1 is always i686 and msys2 is always x86_64. | |
416 | # instead, msys defines $MSYSTEM which is MINGW32 on i686 and | |
417 | # MINGW64 on x86_64. | |
418 | CFG_CPUTYPE=i686 | |
419 | CFG_OSTYPE=pc-windows-gnu | |
420 | if [ "$MSYSTEM" = MINGW64 ] | |
421 | then | |
422 | CFG_CPUTYPE=x86_64 | |
423 | fi | |
223e47cc | 424 | ;; |
1a4d82fc JJ |
425 | |
426 | MSYS*) | |
427 | CFG_OSTYPE=pc-windows-gnu | |
428 | ;; | |
429 | ||
c34b1796 | 430 | # Thad's Cygwin identifiers below |
223e47cc LB |
431 | |
432 | # Vista 32 bit | |
433 | CYGWIN_NT-6.0) | |
1a4d82fc | 434 | CFG_OSTYPE=pc-windows-gnu |
223e47cc LB |
435 | CFG_CPUTYPE=i686 |
436 | ;; | |
437 | ||
438 | # Vista 64 bit | |
439 | CYGWIN_NT-6.0-WOW64) | |
1a4d82fc | 440 | CFG_OSTYPE=pc-windows-gnu |
223e47cc LB |
441 | CFG_CPUTYPE=x86_64 |
442 | ;; | |
443 | ||
444 | # Win 7 32 bit | |
445 | CYGWIN_NT-6.1) | |
1a4d82fc | 446 | CFG_OSTYPE=pc-windows-gnu |
223e47cc LB |
447 | CFG_CPUTYPE=i686 |
448 | ;; | |
449 | ||
450 | # Win 7 64 bit | |
451 | CYGWIN_NT-6.1-WOW64) | |
1a4d82fc | 452 | CFG_OSTYPE=pc-windows-gnu |
223e47cc LB |
453 | CFG_CPUTYPE=x86_64 |
454 | ;; | |
455 | ||
c34b1796 AL |
456 | # Win 8 # uname -s on 64-bit cygwin does not contain WOW64, so simply use uname -m to detect arch (works in my install) |
457 | CYGWIN_NT-6.3) | |
458 | CFG_OSTYPE=pc-windows-gnu | |
459 | ;; | |
223e47cc LB |
460 | # We do not detect other OS such as XP/2003 using 64 bit using uname. |
461 | # 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. | |
462 | *) | |
463 | err "unknown OS type: $CFG_OSTYPE" | |
464 | ;; | |
465 | esac | |
466 | ||
467 | ||
468 | case $CFG_CPUTYPE in | |
469 | ||
470 | i386 | i486 | i686 | i786 | x86) | |
471 | CFG_CPUTYPE=i686 | |
472 | ;; | |
473 | ||
474 | xscale | arm) | |
475 | CFG_CPUTYPE=arm | |
476 | ;; | |
477 | ||
1a4d82fc JJ |
478 | armv7l) |
479 | CFG_CPUTYPE=arm | |
480 | CFG_OSTYPE="${CFG_OSTYPE}eabihf" | |
481 | ;; | |
482 | ||
483 | aarch64) | |
484 | CFG_CPUTYPE=aarch64 | |
485 | ;; | |
486 | ||
c34b1796 AL |
487 | # At some point, when ppc64[le] support happens, this will need to do |
488 | # something clever. For now it's safe to assume that we're only ever | |
489 | # interested in building 32 bit. | |
490 | powerpc | ppc | ppc64) | |
85aaf69f SL |
491 | CFG_CPUTYPE=powerpc |
492 | ;; | |
493 | ||
223e47cc LB |
494 | x86_64 | x86-64 | x64 | amd64) |
495 | CFG_CPUTYPE=x86_64 | |
496 | ;; | |
497 | ||
498 | *) | |
499 | err "unknown CPU type: $CFG_CPUTYPE" | |
500 | esac | |
501 | ||
502 | # Detect 64 bit linux systems with 32 bit userland and force 32 bit compilation | |
503 | if [ $CFG_OSTYPE = unknown-linux-gnu -a $CFG_CPUTYPE = x86_64 ] | |
504 | then | |
c34b1796 AL |
505 | # $SHELL does not exist in standard 'sh', so probably only exists |
506 | # if configure is running in an interactive bash shell. /usr/bin/env | |
507 | # exists *everywhere*. | |
508 | BIN_TO_PROBE="$SHELL" | |
509 | if [ -z "$BIN_TO_PROBE" -a -e "/usr/bin/env" ]; then | |
510 | BIN_TO_PROBE="/usr/bin/env" | |
223e47cc | 511 | fi |
c34b1796 AL |
512 | if [ -n "$BIN_TO_PROBE" ]; then |
513 | file -L "$BIN_TO_PROBE" | grep -q "x86[_-]64" | |
514 | if [ $? != 0 ]; then | |
515 | CFG_CPUTYPE=i686 | |
516 | fi | |
517 | fi | |
223e47cc LB |
518 | fi |
519 | ||
520 | ||
1a4d82fc | 521 | DEFAULT_BUILD="${CFG_CPUTYPE}-${CFG_OSTYPE}" |
223e47cc | 522 | |
d9579d0f | 523 | CFG_SRC_DIR="$(abs_path $(dirname $0))/" |
62682a34 | 524 | CFG_SRC_DIR_RELATIVE="$(dirname $0)/" |
223e47cc | 525 | CFG_BUILD_DIR="$(pwd)/" |
1a4d82fc | 526 | CFG_SELF="$0" |
223e47cc LB |
527 | CFG_CONFIGURE_ARGS="$@" |
528 | ||
529 | OPTIONS="" | |
530 | HELP=0 | |
531 | if [ "$1" = "--help" ] | |
532 | then | |
533 | HELP=1 | |
534 | shift | |
970d7e83 | 535 | echo |
223e47cc | 536 | echo "Usage: $CFG_SELF [options]" |
970d7e83 | 537 | echo |
223e47cc | 538 | echo "Options:" |
970d7e83 | 539 | echo |
223e47cc LB |
540 | else |
541 | msg "recreating config.tmp" | |
542 | echo '' >config.tmp | |
543 | ||
544 | step_msg "processing $CFG_SELF args" | |
545 | fi | |
546 | ||
547 | BOOL_OPTIONS="" | |
548 | VAL_OPTIONS="" | |
549 | ||
d9579d0f | 550 | opt debug 0 "debug mode; disables optimization unless \`--enable-optimize\` given" |
223e47cc LB |
551 | opt valgrind 0 "run tests with valgrind (memcheck by default)" |
552 | opt helgrind 0 "run tests with helgrind instead of memcheck" | |
1a4d82fc | 553 | opt valgrind-rpass 1 "run rpass-valgrind tests with valgrind" |
c34b1796 AL |
554 | opt docs 1 "build standard library documentation" |
555 | opt compiler-docs 0 "build compiler documentation" | |
1a4d82fc | 556 | opt optimize-tests 1 "build tests with optimizations" |
d9579d0f | 557 | opt debuginfo-tests 0 "build tests with debugger metadata" |
1a4d82fc | 558 | opt libcpp 1 "build with llvm with libc++ instead of libstdc++ when using clang" |
9346a6ac AL |
559 | opt llvm-assertions 0 "build LLVM with assertions" |
560 | opt debug-assertions 0 "build with debugging assertions" | |
223e47cc | 561 | opt fast-make 0 "use .gitmodules as timestamp for submodule deps" |
970d7e83 | 562 | opt ccache 0 "invoke gcc/clang via ccache to reuse object files between builds" |
223e47cc | 563 | opt local-rust 0 "use an installed rustc rather than downloading a snapshot" |
1a4d82fc JJ |
564 | opt llvm-static-stdcpp 0 "statically link to libstdc++ for LLVM" |
565 | opt rpath 0 "build rpaths into rustc itself" | |
1a4d82fc JJ |
566 | # This is used by the automation to produce single-target nightlies |
567 | opt dist-host-only 0 "only install bins for the host architecture" | |
568 | opt inject-std-version 1 "inject the current compiler version of libstd into programs" | |
62682a34 | 569 | opt llvm-version-check 1 "check if the LLVM version is supported, build anyway" |
1a4d82fc | 570 | |
9346a6ac AL |
571 | # Optimization and debugging options. These may be overridden by the release channel, etc. |
572 | opt_nosave optimize 1 "build optimized rust code" | |
573 | opt_nosave optimize-cxx 1 "build optimized C++ code" | |
574 | opt_nosave optimize-llvm 1 "build optimized LLVM" | |
575 | opt_nosave llvm-assertions 0 "build LLVM with assertions" | |
576 | opt_nosave debug-assertions 0 "build with debugging assertions" | |
577 | opt_nosave debuginfo 0 "build with debugger metadata" | |
578 | opt_nosave debug-jemalloc 0 "build jemalloc with --enable-debug --enable-fill" | |
579 | ||
1a4d82fc JJ |
580 | valopt localstatedir "/var/lib" "local state directory" |
581 | valopt sysconfdir "/etc" "install system configuration files" | |
582 | ||
583 | valopt datadir "${CFG_PREFIX}/share" "install data" | |
584 | valopt infodir "${CFG_PREFIX}/share/info" "install additional info" | |
223e47cc | 585 | valopt llvm-root "" "set LLVM root" |
62682a34 | 586 | valopt python "" "set path to python" |
1a4d82fc JJ |
587 | valopt jemalloc-root "" "set directory where libjemalloc_pic.a is located" |
588 | valopt build "${DEFAULT_BUILD}" "GNUs ./configure syntax LLVM build triple" | |
223e47cc | 589 | valopt android-cross-path "/opt/ndk_standalone" "Android NDK standalone path" |
9346a6ac | 590 | valopt release-channel "dev" "the name of the release channel to build" |
d9579d0f | 591 | valopt musl-root "/usr/local" "MUSL root installation directory" |
223e47cc | 592 | |
1a4d82fc JJ |
593 | # Many of these are saved below during the "writing configuration" step |
594 | # (others are conditionally saved). | |
595 | opt_nosave manage-submodules 1 "let the build manage the git submodules" | |
596 | opt_nosave clang 0 "prefer clang to gcc for building the runtime" | |
9346a6ac | 597 | opt_nosave jemalloc 1 "build liballoc with jemalloc" |
d9579d0f | 598 | opt elf-tls 1 "elf thread local storage on platforms where supported" |
1a4d82fc JJ |
599 | |
600 | valopt_nosave prefix "/usr/local" "set installation prefix" | |
601 | valopt_nosave local-rust-root "/usr/local" "set prefix for local rust binary" | |
602 | valopt_nosave host "${CFG_BUILD}" "GNUs ./configure syntax LLVM host triples" | |
603 | valopt_nosave target "${CFG_HOST}" "GNUs ./configure syntax LLVM target triples" | |
604 | valopt_nosave mandir "${CFG_PREFIX}/share/man" "install man pages in PATH" | |
1a4d82fc JJ |
605 | |
606 | # Temporarily support old triples until buildbots get updated | |
607 | CFG_BUILD=$(to_llvm_triple $CFG_BUILD) | |
608 | putvar CFG_BUILD # Yes, this creates a duplicate entry, but the last one wins. | |
609 | CFG_HOST=$(to_llvm_triple $CFG_HOST) | |
610 | CFG_TARGET=$(to_llvm_triple $CFG_TARGET) | |
611 | ||
612 | # On windows we just store the libraries in the bin directory because | |
613 | # there's no rpath. This is where the build system itself puts libraries; | |
614 | # --libdir is used to configure the installation directory. | |
615 | # FIXME: This needs to parameterized over target triples. Do it in platform.mk | |
62682a34 | 616 | if [ "$CFG_OSTYPE" = "pc-windows-gnu" ] || [ "$CFG_OSTYPE" = "pc-windows-msvc" ] |
1a4d82fc JJ |
617 | then |
618 | CFG_LIBDIR_RELATIVE=bin | |
619 | else | |
620 | CFG_LIBDIR_RELATIVE=lib | |
621 | fi | |
622 | ||
623 | valopt libdir "${CFG_PREFIX}/${CFG_LIBDIR_RELATIVE}" "install libraries (do not set it on windows platform)" | |
624 | ||
625 | case "$CFG_LIBDIR" in | |
626 | "$CFG_PREFIX"/*) CAT_INC=2;; | |
627 | "$CFG_PREFIX"*) CAT_INC=1;; | |
628 | *) | |
629 | err "libdir must begin with the prefix. Use --prefix to set it accordingly.";; | |
630 | esac | |
631 | ||
632 | CFG_LIBDIR_RELATIVE=`echo ${CFG_LIBDIR} | cut -c$((${#CFG_PREFIX}+${CAT_INC}))-` | |
633 | ||
62682a34 SL |
634 | if ( [ "$CFG_OSTYPE" = "pc-windows-gnu" ] || [ "$CFG_OSTYPE" = "pc-windows-msvc" ] ) \ |
635 | && [ "$CFG_LIBDIR_RELATIVE" != "bin" ]; then | |
1a4d82fc JJ |
636 | err "libdir on windows should be set to 'bin'" |
637 | fi | |
223e47cc LB |
638 | |
639 | if [ $HELP -eq 1 ] | |
640 | then | |
970d7e83 | 641 | echo |
223e47cc LB |
642 | exit 0 |
643 | fi | |
644 | ||
1a4d82fc JJ |
645 | # Validate Options |
646 | step_msg "validating $CFG_SELF args" | |
647 | validate_opt | |
648 | ||
9346a6ac | 649 | # Validate the release channel, and configure options |
1a4d82fc | 650 | case "$CFG_RELEASE_CHANNEL" in |
9346a6ac AL |
651 | nightly ) |
652 | msg "overriding settings for $CFG_RELEASE_CHANNEL" | |
653 | CFG_ENABLE_LLVM_ASSERTIONS=1 | |
1a4d82fc | 654 | ;; |
9346a6ac AL |
655 | dev | beta | stable) |
656 | ;; | |
657 | *) | |
1a4d82fc JJ |
658 | err "release channel must be 'dev', 'nightly', 'beta' or 'stable'" |
659 | ;; | |
660 | esac | |
661 | ||
9346a6ac AL |
662 | # Adjust perf and debug options for debug mode |
663 | if [ -n "$CFG_ENABLE_DEBUG" ]; then | |
664 | msg "debug mode enabled, setting performance options" | |
665 | if [ -z "$CFG_ENABLE_OPTIMIZE_PROVIDED" ]; then | |
666 | msg "optimization not explicitly enabled, disabling optimization" | |
667 | CFG_DISABLE_OPTIMIZE=1 | |
668 | CFG_DISABLE_OPTIMIZE_CXX=1 | |
669 | fi | |
9346a6ac AL |
670 | CFG_ENABLE_DEBUG_ASSERTIONS=1 |
671 | CFG_ENABLE_DEBUG_JEMALLOC=1 | |
d9579d0f AL |
672 | CFG_ENABLE_DEBUGINFO=1 |
673 | CFG_ENABLE_LLVM_ASSERTIONS=1 | |
1a4d82fc | 674 | fi |
9346a6ac AL |
675 | |
676 | # OK, now write the debugging options | |
677 | if [ -n "$CFG_DISABLE_OPTIMIZE" ]; then putvar CFG_DISABLE_OPTIMIZE; fi | |
678 | if [ -n "$CFG_DISABLE_OPTIMIZE_CXX" ]; then putvar CFG_DISABLE_OPTIMIZE_CXX; fi | |
679 | if [ -n "$CFG_DISABLE_OPTIMIZE_LLVM" ]; then putvar CFG_DISABLE_OPTIMIZE_LLVM; fi | |
680 | if [ -n "$CFG_ENABLE_LLVM_ASSERTIONS" ]; then putvar CFG_ENABLE_LLVM_ASSERTIONS; fi | |
681 | if [ -n "$CFG_ENABLE_DEBUG_ASSERTIONS" ]; then putvar CFG_ENABLE_DEBUG_ASSERTIONS; fi | |
682 | if [ -n "$CFG_ENABLE_DEBUGINFO" ]; then putvar CFG_ENABLE_DEBUGINFO; fi | |
683 | if [ -n "$CFG_ENABLE_DEBUG_JEMALLOC" ]; then putvar CFG_ENABLE_DEBUG_JEMALLOC; fi | |
1a4d82fc JJ |
684 | |
685 | # A magic value that allows the compiler to use unstable features | |
686 | # during the bootstrap even when doing so would normally be an error | |
687 | # because of feature staging or because the build turns on | |
688 | # warnings-as-errors and unstable features default to warnings. The | |
689 | # build has to match this key in an env var. Meant to be a mild | |
690 | # deterrent from users just turning on unstable features on the stable | |
691 | # channel. | |
692 | # Basing CFG_BOOTSTRAP_KEY on CFG_BOOTSTRAP_KEY lets it get picked up | |
693 | # during a Makefile reconfig. | |
85aaf69f | 694 | CFG_BOOTSTRAP_KEY="${CFG_BOOTSTRAP_KEY-`date +%H:%M:%S`}" |
1a4d82fc | 695 | putvar CFG_BOOTSTRAP_KEY |
223e47cc LB |
696 | |
697 | step_msg "looking for build programs" | |
698 | ||
1a4d82fc | 699 | probe_need CFG_CURLORWGET curl wget |
62682a34 SL |
700 | if [ -z "$CFG_PYTHON_PROVIDED" ]; then |
701 | probe_need CFG_PYTHON python2.7 python2.6 python2 python | |
702 | fi | |
223e47cc LB |
703 | |
704 | python_version=$($CFG_PYTHON -V 2>&1) | |
705 | if [ $(echo $python_version | grep -c '^Python 2\.[4567]') -ne 1 ]; then | |
706 | err "Found $python_version, but LLVM requires Python 2.4-2.7" | |
707 | fi | |
708 | ||
709 | # If we have no git directory then we are probably a tarball distribution | |
710 | # and shouldn't attempt to load submodules | |
711 | if [ ! -e ${CFG_SRC_DIR}.git ] | |
712 | then | |
713 | probe CFG_GIT git | |
714 | msg "git: no git directory. disabling submodules" | |
715 | CFG_DISABLE_MANAGE_SUBMODULES=1 | |
716 | else | |
717 | probe_need CFG_GIT git | |
718 | fi | |
719 | ||
d9579d0f AL |
720 | # Use `md5sum` on GNU platforms, or `md5 -q` on BSD |
721 | probe CFG_MD5 md5 | |
722 | probe CFG_MD5SUM md5sum | |
723 | if [ -n "$CFG_MD5" ] | |
724 | then | |
62682a34 | 725 | CFG_HASH_COMMAND="$CFG_MD5 -q | cut -c 1-8" |
d9579d0f AL |
726 | elif [ -n "$CFG_MD5SUM" ] |
727 | then | |
62682a34 | 728 | CFG_HASH_COMMAND="$CFG_MD5SUM | cut -c 1-8" |
d9579d0f AL |
729 | else |
730 | err 'could not find one of: md5 md5sum' | |
731 | fi | |
732 | putvar CFG_HASH_COMMAND | |
733 | ||
223e47cc | 734 | probe CFG_CLANG clang++ |
970d7e83 | 735 | probe CFG_CCACHE ccache |
223e47cc LB |
736 | probe CFG_GCC gcc |
737 | probe CFG_LD ld | |
738 | probe CFG_VALGRIND valgrind | |
739 | probe CFG_PERF perf | |
740 | probe CFG_ISCC iscc | |
1a4d82fc JJ |
741 | probe CFG_ANTLR4 antlr4 |
742 | probe CFG_GRUN grun | |
85aaf69f SL |
743 | probe CFG_FLEX flex |
744 | probe CFG_BISON bison | |
223e47cc | 745 | probe CFG_PANDOC pandoc |
1a4d82fc | 746 | probe CFG_XELATEX xelatex |
223e47cc | 747 | probe CFG_GDB gdb |
1a4d82fc JJ |
748 | probe CFG_LLDB lldb |
749 | ||
9346a6ac AL |
750 | # On MacOS X, invoking `javac` pops up a dialog if the JDK is not |
751 | # installed. Since `javac` is only used if `antlr4` is available, | |
752 | # probe for it only in this case. | |
753 | if [ ! -z "$CFG_ANTLR4" ] | |
754 | then | |
755 | probe CFG_JAVAC javac | |
756 | fi | |
757 | ||
d9579d0f AL |
758 | # the valgrind rpass tests will fail if you don't have a valgrind, but they're |
759 | # only disabled if you opt out. | |
760 | if [ -z "$CFG_VALGRIND" ] | |
761 | then | |
762 | # If the user has explicitly asked for valgrind tests, then fail | |
763 | if [ -n "$CFG_ENABLE_VALGRIND" ] && [ -n "$CFG_ENABLE_VALGRIND_PROVIDED" ] | |
764 | then | |
765 | err "No valgrind present, but valgrind tests explicitly requested" | |
766 | else | |
767 | CFG_DISABLE_VALGRIND_RPASS=1 | |
768 | putvar CFG_DISABLE_VALGRIND_RPASS | |
769 | fi | |
770 | fi | |
771 | ||
1a4d82fc | 772 | if [ ! -z "$CFG_GDB" ] |
223e47cc | 773 | then |
1a4d82fc JJ |
774 | # Store GDB's version |
775 | CFG_GDB_VERSION=$($CFG_GDB --version 2>/dev/null | head -1) | |
776 | putvar CFG_GDB_VERSION | |
777 | fi | |
778 | ||
779 | if [ ! -z "$CFG_LLDB" ] | |
780 | then | |
781 | # Store LLDB's version | |
782 | CFG_LLDB_VERSION=$($CFG_LLDB --version 2>/dev/null | head -1) | |
783 | putvar CFG_LLDB_VERSION | |
784 | ||
785 | # If CFG_LLDB_PYTHON_DIR is not already set from the outside and valid, try to read it from | |
786 | # LLDB via the -P commandline options. | |
787 | if [ -z "$CFG_LLDB_PYTHON_DIR" ] || [ ! -d "$CFG_LLDB_PYTHON_DIR" ] | |
788 | then | |
789 | CFG_LLDB_PYTHON_DIR=$($CFG_LLDB -P) | |
790 | ||
791 | # If CFG_LLDB_PYTHON_DIR is not a valid directory, set it to something more readable | |
792 | if [ ! -d "$CFG_LLDB_PYTHON_DIR" ] | |
793 | then | |
794 | CFG_LLDB_PYTHON_DIR="LLDB_PYTHON_DIRECTORY_NOT_FOUND" | |
795 | fi | |
796 | ||
797 | putvar CFG_LLDB_PYTHON_DIR | |
798 | fi | |
223e47cc LB |
799 | fi |
800 | ||
970d7e83 LB |
801 | step_msg "looking for target specific programs" |
802 | ||
803 | probe CFG_ADB adb | |
804 | ||
223e47cc LB |
805 | if [ ! -z "$CFG_PANDOC" ] |
806 | then | |
c34b1796 AL |
807 | # Extract "MAJOR MINOR" from Pandoc's version number |
808 | PV_MAJOR_MINOR=$(pandoc --version | grep '^pandoc' | | |
809 | sed -E 's/pandoc(.exe)? ([0-9]+)\.([0-9]+).*/\2 \3/') | |
223e47cc | 810 | |
1a4d82fc JJ |
811 | MIN_PV_MAJOR="1" |
812 | MIN_PV_MINOR="9" | |
c34b1796 | 813 | |
223e47cc LB |
814 | # these patterns are shell globs, *not* regexps |
815 | PV_MAJOR=${PV_MAJOR_MINOR% *} | |
816 | PV_MINOR=${PV_MAJOR_MINOR#* } | |
c34b1796 | 817 | |
1a4d82fc | 818 | if [ "$PV_MAJOR" -lt "$MIN_PV_MAJOR" ] || [ "$PV_MINOR" -lt "$MIN_PV_MINOR" ] |
223e47cc | 819 | then |
1a4d82fc JJ |
820 | step_msg "pandoc $PV_MAJOR.$PV_MINOR is too old. Need at least $MIN_PV_MAJOR.$MIN_PV_MINOR. Disabling" |
821 | BAD_PANDOC=1 | |
223e47cc LB |
822 | fi |
823 | fi | |
824 | ||
1a4d82fc | 825 | BIN_SUF= |
62682a34 | 826 | if [ "$CFG_OSTYPE" = "pc-windows-gnu" ] || [ "$CFG_OSTYPE" = "pc-windows-msvc" ] |
223e47cc | 827 | then |
1a4d82fc | 828 | BIN_SUF=.exe |
223e47cc LB |
829 | fi |
830 | ||
831 | if [ ! -z "$CFG_ENABLE_LOCAL_RUST" ] | |
832 | then | |
1a4d82fc JJ |
833 | system_rustc=$(which rustc) |
834 | if [ -f ${CFG_LOCAL_RUST_ROOT}/bin/rustc${BIN_SUF} ] | |
223e47cc | 835 | then |
1a4d82fc JJ |
836 | : # everything already configured |
837 | elif [ -n "$system_rustc" ] | |
838 | then | |
839 | # we assume that rustc is in a /bin directory | |
840 | CFG_LOCAL_RUST_ROOT=${system_rustc%/bin/rustc} | |
223e47cc | 841 | else |
1a4d82fc | 842 | err "no local rust to use" |
223e47cc | 843 | fi |
1a4d82fc JJ |
844 | |
845 | CMD="${CFG_LOCAL_RUST_ROOT}/bin/rustc${BIN_SUF}" | |
846 | LRV=`$CMD --version` | |
847 | if [ $? -ne 0 ] | |
848 | then | |
849 | step_msg "failure while running $CMD --version" | |
850 | exit 1 | |
851 | fi | |
852 | step_msg "using rustc at: ${CFG_LOCAL_RUST_ROOT} with version: $LRV" | |
853 | putvar CFG_LOCAL_RUST_ROOT | |
223e47cc LB |
854 | fi |
855 | ||
c34b1796 AL |
856 | # Force bitrig to build with clang; gcc doesn't like us there |
857 | if [ $CFG_OSTYPE = unknown-bitrig ] | |
858 | then | |
859 | step_msg "on Bitrig, forcing use of clang, disabling jemalloc" | |
860 | CFG_ENABLE_CLANG=1 | |
9346a6ac | 861 | CFG_DISABLE_JEMALLOC=1 |
c34b1796 AL |
862 | fi |
863 | ||
1a4d82fc JJ |
864 | # OS X 10.9, gcc is actually clang. This can cause some confusion in the build |
865 | # system, so if we find that gcc is clang, we should just use clang directly. | |
866 | if [ $CFG_OSTYPE = apple-darwin -a -z "$CFG_ENABLE_CLANG" ] | |
867 | then | |
868 | CFG_OSX_GCC_VERSION=$("$CFG_GCC" --version 2>&1 | grep "Apple LLVM version") | |
869 | if [ $? -eq 0 ] | |
870 | then | |
d9579d0f | 871 | step_msg "on OS X >=10.9, forcing use of clang" |
1a4d82fc JJ |
872 | CFG_ENABLE_CLANG=1 |
873 | else | |
874 | if [ $("$CFG_GCC" --version 2>&1 | grep -c ' 4\.[0-6]') -ne 0 ]; then | |
875 | step_msg "older GCC found, using clang instead" | |
876 | CFG_ENABLE_CLANG=1 | |
877 | else | |
878 | # on OS X, with xcode 5 and newer, certain developers may have | |
879 | # cc, gcc and g++ point to a mixture of clang and gcc | |
880 | # if so, this will create very strange build errors | |
881 | # this last stanza is to detect some such problems and save the future rust | |
882 | # contributor some time solving that issue. | |
883 | # this detection could be generalized to other OSes aside from OS X | |
884 | # but the issue seems most likely to happen on OS X | |
885 | ||
886 | chk_cc () { | |
887 | $1 --version 2> /dev/null | grep -q $2 | |
888 | } | |
889 | # check that gcc, cc and g++ all point to the same compiler. | |
890 | # note that for xcode 5, g++ points to clang, not clang++ | |
891 | if !((chk_cc gcc clang && chk_cc g++ clang) || | |
892 | (chk_cc gcc gcc &&( chk_cc g++ g++ || chk g++ gcc))); then | |
893 | err "the gcc and g++ in your path point to different compilers. | |
894 | Check which versions are in your path with gcc --version and g++ --version. | |
895 | To resolve this problem, either fix your PATH or run configure with --enable-clang" | |
896 | fi | |
897 | ||
898 | fi | |
899 | fi | |
900 | fi | |
901 | ||
902 | # Okay, at this point, we have made up our minds about whether we are | |
903 | # going to force CFG_ENABLE_CLANG or not; save the setting if so. | |
904 | if [ ! -z "$CFG_ENABLE_CLANG" ] | |
905 | then | |
906 | putvar CFG_ENABLE_CLANG | |
907 | fi | |
908 | ||
9346a6ac AL |
909 | # Same with jemalloc. save the setting here. |
910 | if [ ! -z "$CFG_DISABLE_JEMALLOC" ] | |
911 | then | |
912 | putvar CFG_DISABLE_JEMALLOC | |
913 | fi | |
914 | ||
85aaf69f | 915 | if [ ! -z "$CFG_LLVM_ROOT" -a -z "$CFG_DISABLE_LLVM_VERSION_CHECK" -a -e "$CFG_LLVM_ROOT/bin/llvm-config" ] |
223e47cc LB |
916 | then |
917 | step_msg "using custom LLVM at $CFG_LLVM_ROOT" | |
918 | ||
919 | LLVM_CONFIG="$CFG_LLVM_ROOT/bin/llvm-config" | |
920 | LLVM_VERSION=$($LLVM_CONFIG --version) | |
921 | ||
922 | case $LLVM_VERSION in | |
c34b1796 | 923 | (3.[5-6]*) |
1a4d82fc JJ |
924 | msg "found ok version of LLVM: $LLVM_VERSION" |
925 | ;; | |
926 | (*) | |
c34b1796 | 927 | err "bad LLVM version: $LLVM_VERSION, need >=3.5" |
1a4d82fc | 928 | ;; |
223e47cc LB |
929 | esac |
930 | fi | |
931 | ||
1a4d82fc JJ |
932 | # Even when the user overrides the choice of CC, still try to detect |
933 | # clang to disable some clang-specific warnings. We here draw a | |
934 | # distinction between: | |
935 | # | |
936 | # CFG_ENABLE_CLANG : passed --enable-clang, or host "requires" clang, | |
937 | # CFG_USING_CLANG : compiler (clang / gcc / $CC) looks like clang. | |
938 | # | |
939 | # This distinction is important because there are some safeguards we | |
940 | # would prefer to skip when merely CFG_USING_CLANG is set; but when | |
941 | # CFG_ENABLE_CLANG is set, that indicates that we are opting into | |
942 | # running such safeguards. | |
943 | ||
944 | if [ ! -z "$CC" ] | |
223e47cc | 945 | then |
1a4d82fc JJ |
946 | msg "skipping compiler inference steps; using provided CC=$CC" |
947 | CFG_CC="$CC" | |
948 | ||
949 | CFG_OSX_CC_VERSION=$("$CFG_CC" --version 2>&1 | grep "clang") | |
950 | if [ $? -eq 0 ] | |
223e47cc | 951 | then |
1a4d82fc JJ |
952 | step_msg "note, user-provided CC looks like clang; CC=$CC." |
953 | CFG_USING_CLANG=1 | |
954 | putvar CFG_USING_CLANG | |
223e47cc | 955 | fi |
223e47cc | 956 | else |
1a4d82fc JJ |
957 | if [ ! -z "$CFG_ENABLE_CLANG" ] |
958 | then | |
959 | if [ -z "$CFG_CLANG" ] | |
960 | then | |
961 | err "clang requested but not found" | |
962 | fi | |
963 | CFG_CC="$CFG_CLANG" | |
964 | CFG_USING_CLANG=1 | |
965 | putvar CFG_USING_CLANG | |
966 | else | |
967 | CFG_CC="gcc" | |
968 | fi | |
969 | fi | |
970 | ||
971 | if [ ! -z "$CFG_ENABLE_CLANG" ] | |
972 | then | |
62682a34 SL |
973 | case "$CC" in |
974 | (''|*clang) | |
975 | CFG_CLANG_REPORTED_VERSION=$($CFG_CC --version | grep version) | |
976 | ||
977 | if [[ $CFG_CLANG_REPORTED_VERSION == *"(based on LLVM "* ]] | |
978 | then | |
979 | CFG_CLANG_VERSION=$(echo $CFG_CLANG_REPORTED_VERSION | sed 's/.*(based on LLVM \(.*\))/\1/') | |
980 | elif [[ $CFG_CLANG_REPORTED_VERSION == "Apple LLVM"* ]] | |
981 | then | |
982 | CFG_OSX_CLANG_VERSION=$(echo $CFG_CLANG_REPORTED_VERSION | sed 's/.*version \(.*\) .*/\1/') | |
983 | else | |
984 | CFG_CLANG_VERSION=$(echo $CFG_CLANG_REPORTED_VERSION | sed 's/.*version \(.*\) .*/\1/') | |
985 | fi | |
986 | ||
987 | if [ ! -z "$CFG_OSX_CLANG_VERSION" ] | |
988 | then | |
989 | case $CFG_OSX_CLANG_VERSION in | |
990 | (7.0*) | |
991 | step_msg "found ok version of APPLE CLANG: $CFG_OSX_CLANG_VERSION" | |
992 | ;; | |
993 | (*) | |
994 | err "bad APPLE CLANG version: $CFG_OSX_CLANG_VERSION, need >=7.0" | |
995 | ;; | |
996 | esac | |
997 | else | |
998 | case $CFG_CLANG_VERSION in | |
999 | (3.2* | 3.3* | 3.4* | 3.5* | 3.6* | 3.7*) | |
1000 | step_msg "found ok version of CLANG: $CFG_CLANG_VERSION" | |
1001 | ;; | |
1002 | (*) | |
1003 | err "bad CLANG version: $CFG_CLANG_VERSION, need >=3.0svn" | |
1004 | ;; | |
1005 | esac | |
1006 | fi | |
1007 | ||
1008 | if [ -z "$CC" ] | |
1009 | then | |
1010 | CFG_CC="clang" | |
1011 | CFG_CXX="clang++" | |
1012 | fi | |
1013 | esac | |
223e47cc LB |
1014 | fi |
1015 | ||
970d7e83 LB |
1016 | if [ ! -z "$CFG_ENABLE_CCACHE" ] |
1017 | then | |
1a4d82fc | 1018 | if [ -z "$CC" ] |
970d7e83 | 1019 | then |
1a4d82fc JJ |
1020 | if [ -z "$CFG_CCACHE" ] |
1021 | then | |
1022 | err "ccache requested but not found" | |
1023 | fi | |
1024 | ||
1025 | CFG_CC="ccache $CFG_CC" | |
970d7e83 | 1026 | fi |
1a4d82fc | 1027 | fi |
970d7e83 | 1028 | |
1a4d82fc JJ |
1029 | if [ -z "$CC" -a -z "$CFG_ENABLE_CLANG" -a -z "$CFG_GCC" ] |
1030 | then | |
1031 | err "either clang or gcc is required" | |
970d7e83 LB |
1032 | fi |
1033 | ||
1a4d82fc JJ |
1034 | # All safeguards based on $CFG_ENABLE_CLANG should occur before this |
1035 | # point in the script; after this point, script logic should inspect | |
1036 | # $CFG_USING_CLANG rather than $CFG_ENABLE_CLANG. | |
1037 | ||
1038 | # Set CFG_{CC,CXX,CPP,CFLAGS,CXXFLAGS} | |
1039 | envopt CC | |
1040 | envopt CXX | |
1041 | envopt CPP | |
1042 | envopt CFLAGS | |
1043 | envopt CXXFLAGS | |
223e47cc | 1044 | |
1a4d82fc | 1045 | # a little post-processing of various config values |
223e47cc | 1046 | CFG_PREFIX=${CFG_PREFIX%/} |
1a4d82fc JJ |
1047 | CFG_MANDIR=${CFG_MANDIR%/} |
1048 | CFG_HOST="$(echo $CFG_HOST | tr ',' ' ')" | |
1049 | CFG_TARGET="$(echo $CFG_TARGET | tr ',' ' ')" | |
1050 | CFG_SUPPORTED_TARGET="" | |
1051 | for target_file in ${CFG_SRC_DIR}mk/cfg/*.mk; do | |
1052 | CFG_SUPPORTED_TARGET="${CFG_SUPPORTED_TARGET} $(basename "$target_file" .mk)" | |
1053 | done | |
223e47cc LB |
1054 | |
1055 | # copy host-triples to target-triples so that hosts are a subset of targets | |
1056 | V_TEMP="" | |
1a4d82fc | 1057 | for i in $CFG_HOST $CFG_TARGET; |
223e47cc LB |
1058 | do |
1059 | echo "$V_TEMP" | grep -qF $i || V_TEMP="$V_TEMP${V_TEMP:+ }$i" | |
1060 | done | |
1a4d82fc | 1061 | CFG_TARGET=$V_TEMP |
223e47cc LB |
1062 | |
1063 | # check target-specific tool-chains | |
1a4d82fc | 1064 | for i in $CFG_TARGET |
223e47cc LB |
1065 | do |
1066 | L_CHECK=false | |
1a4d82fc | 1067 | for j in $CFG_SUPPORTED_TARGET |
223e47cc LB |
1068 | do |
1069 | if [ $i = $j ] | |
1070 | then | |
1071 | L_CHECK=true | |
1072 | fi | |
1073 | done | |
1074 | ||
1075 | if [ $L_CHECK = false ] | |
1076 | then | |
1077 | err "unsupported target triples \"$i\" found" | |
1078 | fi | |
1079 | ||
1080 | case $i in | |
1081 | arm-linux-androideabi) | |
1082 | ||
1083 | if [ ! -f $CFG_ANDROID_CROSS_PATH/bin/arm-linux-androideabi-gcc ] | |
1084 | then | |
1085 | err "NDK $CFG_ANDROID_CROSS_PATH/bin/arm-linux-androideabi-gcc not found" | |
1086 | fi | |
1087 | if [ ! -f $CFG_ANDROID_CROSS_PATH/bin/arm-linux-androideabi-g++ ] | |
1088 | then | |
1089 | err "NDK $CFG_ANDROID_CROSS_PATH/bin/arm-linux-androideabi-g++ not found" | |
1090 | fi | |
1091 | if [ ! -f $CFG_ANDROID_CROSS_PATH/bin/arm-linux-androideabi-ar ] | |
1092 | then | |
1093 | err "NDK $CFG_ANDROID_CROSS_PATH/bin/arm-linux-androideabi-ar not found" | |
1094 | fi | |
1095 | ;; | |
1096 | ||
1a4d82fc JJ |
1097 | arm-apple-darwin) |
1098 | if [ $CFG_OSTYPE != apple-darwin ] | |
1099 | then | |
1100 | err "The iOS target is only supported on Mac OS X" | |
1101 | fi | |
1102 | ;; | |
1103 | ||
d9579d0f AL |
1104 | |
1105 | *-musl) | |
1106 | if [ ! -f $CFG_MUSL_ROOT/lib/libc.a ] | |
1107 | then | |
1108 | err "musl libc $CFG_MUSL_ROOT/lib/libc.a not found" | |
1109 | fi | |
1110 | ;; | |
62682a34 SL |
1111 | |
1112 | x86_64-*-msvc) | |
1113 | # Currently the build system is not configured to build jemalloc | |
1114 | # with MSVC, so we omit this optional dependency. | |
1115 | step_msg "targeting MSVC, disabling jemalloc" | |
1116 | CFG_DISABLE_JEMALLOC=1 | |
1117 | putvar CFG_DISABLE_JEMALLOC | |
1118 | ||
1119 | # There are some MSYS python builds which will auto-translate | |
1120 | # windows-style paths to MSYS-style paths in Python itself. | |
1121 | # Unfortunately this breaks LLVM's build system as somewhere along | |
1122 | # the line LLVM prints a path into a file from Python and then CMake | |
1123 | # later tries to interpret that path. If Python prints a MSYS path | |
1124 | # and CMake tries to use it as a Windows path, you're gonna have a | |
1125 | # Bad Time. | |
1126 | # | |
1127 | # Consequently here we try to detect when that happens and print an | |
1128 | # error if it does. | |
1129 | if $CFG_PYTHON -c 'import sys; print sys.argv[1]' `pwd` | grep '^/' | |
1130 | then | |
1131 | err "python is silently translating windows paths to MSYS paths \ | |
1132 | and the build will fail if this python is used.\n\n \ | |
1133 | Either an official python install must be used or an \ | |
1134 | alternative python package in MinGW must be used." | |
1135 | fi | |
1136 | ||
1137 | # MSVC requires cmake because that's how we're going to build LLVM | |
1138 | probe_need CFG_CMAKE cmake | |
1139 | ||
1140 | # Use the REG program to figure out where VS is installed | |
1141 | # We need to figure out where cl.exe and link.exe are, so we do some | |
1142 | # munging and some probing here. We also look for the default | |
1143 | # INCLUDE and LIB variables for MSVC so we can set those in the | |
1144 | # build system as well. | |
1145 | install=$(reg QUERY \ | |
1146 | 'HKLM\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\12.0' \ | |
1147 | -v InstallDir) | |
1148 | need_ok "couldn't find visual studio install root" | |
1149 | CFG_MSVC_ROOT=$(echo "$install" | grep InstallDir | sed 's/.*REG_SZ[ ]*//') | |
1150 | CFG_MSVC_ROOT=$(dirname "$CFG_MSVC_ROOT") | |
1151 | CFG_MSVC_ROOT=$(dirname "$CFG_MSVC_ROOT") | |
1152 | CFG_MSVC_CL="${CFG_MSVC_ROOT}/VC/bin/amd64/cl.exe" | |
1153 | CFG_MSVC_LIB="${CFG_MSVC_ROOT}/VC/bin/amd64/lib.exe" | |
1154 | CFG_MSVC_LINK="${CFG_MSVC_ROOT}/VC/bin/amd64/link.exe" | |
1155 | ||
1156 | vcvarsall="${CFG_MSVC_ROOT}/VC/vcvarsall.bat" | |
1157 | CFG_MSVC_INCLUDE_PATH=$(cmd /c "\"$vcvarsall\" amd64 && cmd /c echo %INCLUDE%") | |
1158 | need_ok "failed to learn about MSVC's INCLUDE" | |
1159 | CFG_MSVC_LIB_PATH=$(cmd /c "\"$vcvarsall\" amd64 && cmd /c echo %LIB%") | |
1160 | need_ok "failed to learn about MSVC's LIB" | |
1161 | ||
1162 | putvar CFG_MSVC_ROOT | |
1163 | putvar CFG_MSVC_CL | |
1164 | putvar CFG_MSVC_LIB | |
1165 | putvar CFG_MSVC_LINK | |
1166 | putvar CFG_MSVC_INCLUDE_PATH | |
1167 | putvar CFG_MSVC_LIB_PATH | |
1168 | ;; | |
1169 | ||
223e47cc LB |
1170 | *) |
1171 | ;; | |
1172 | esac | |
1173 | done | |
1174 | ||
223e47cc LB |
1175 | if [ ! -z "$CFG_PERF" ] |
1176 | then | |
1177 | HAVE_PERF_LOGFD=`$CFG_PERF stat --log-fd 2>&1 | grep 'unknown option'` | |
1178 | if [ -z "$HAVE_PERF_LOGFD" ]; | |
1179 | then | |
1180 | CFG_PERF_WITH_LOGFD=1 | |
1181 | putvar CFG_PERF_WITH_LOGFD | |
1182 | fi | |
1183 | fi | |
1184 | ||
1185 | step_msg "making directories" | |
1186 | ||
1187 | for i in \ | |
970d7e83 | 1188 | doc doc/std doc/extra \ |
1a4d82fc | 1189 | dl tmp dist |
223e47cc LB |
1190 | do |
1191 | make_dir $i | |
1192 | done | |
1193 | ||
1a4d82fc | 1194 | for t in $CFG_HOST |
223e47cc | 1195 | do |
1a4d82fc | 1196 | make_dir $t/llvm |
223e47cc LB |
1197 | done |
1198 | ||
1a4d82fc | 1199 | for t in $CFG_HOST |
223e47cc | 1200 | do |
1a4d82fc | 1201 | make_dir $t/rustllvm |
223e47cc LB |
1202 | done |
1203 | ||
1a4d82fc | 1204 | for t in $CFG_TARGET |
223e47cc | 1205 | do |
1a4d82fc | 1206 | make_dir $t/rt |
970d7e83 | 1207 | for s in 0 1 2 3 |
223e47cc | 1208 | do |
1a4d82fc JJ |
1209 | make_dir $t/rt/stage$s |
1210 | make_dir $t/rt/jemalloc | |
62682a34 | 1211 | make_dir $t/rt/compiler-rt |
970d7e83 | 1212 | for i in \ |
1a4d82fc | 1213 | isaac sync test \ |
85aaf69f | 1214 | arch/i386 arch/x86_64 arch/arm arch/aarch64 arch/mips arch/powerpc |
970d7e83 | 1215 | do |
1a4d82fc | 1216 | make_dir $t/rt/stage$s/$i |
970d7e83 | 1217 | done |
223e47cc LB |
1218 | done |
1219 | done | |
1220 | ||
1a4d82fc | 1221 | for h in $CFG_HOST |
223e47cc | 1222 | do |
1a4d82fc | 1223 | for t in $CFG_TARGET |
223e47cc | 1224 | do |
1a4d82fc JJ |
1225 | # host lib dir stage0 |
1226 | make_dir $h/stage0/lib | |
1227 | ||
1228 | # target bin dir stage0 | |
1229 | make_dir $h/stage0/lib/rustlib/$t/bin | |
1230 | ||
1231 | # target lib dir stage0 | |
1232 | make_dir $h/stage0/lib/rustlib/$t/lib | |
1233 | ||
223e47cc LB |
1234 | for i in 0 1 2 3 |
1235 | do | |
1236 | # host bin dir | |
1237 | make_dir $h/stage$i/bin | |
1238 | ||
1239 | # host lib dir | |
1a4d82fc | 1240 | make_dir $h/stage$i/$CFG_LIBDIR_RELATIVE |
223e47cc | 1241 | |
970d7e83 LB |
1242 | # host test dir |
1243 | make_dir $h/stage$i/test | |
1244 | ||
223e47cc | 1245 | # target bin dir |
1a4d82fc | 1246 | make_dir $h/stage$i/$CFG_LIBDIR_RELATIVE/rustlib/$t/bin |
223e47cc LB |
1247 | |
1248 | # target lib dir | |
1a4d82fc | 1249 | make_dir $h/stage$i/$CFG_LIBDIR_RELATIVE/rustlib/$t/lib |
223e47cc LB |
1250 | done |
1251 | done | |
1252 | ||
1253 | make_dir $h/test/run-pass | |
1a4d82fc | 1254 | make_dir $h/test/run-pass-valgrind |
223e47cc LB |
1255 | make_dir $h/test/run-pass-fulldeps |
1256 | make_dir $h/test/run-fail | |
d9579d0f | 1257 | make_dir $h/test/run-fail-fulldeps |
223e47cc | 1258 | make_dir $h/test/compile-fail |
85aaf69f | 1259 | make_dir $h/test/parse-fail |
1a4d82fc | 1260 | make_dir $h/test/compile-fail-fulldeps |
223e47cc LB |
1261 | make_dir $h/test/bench |
1262 | make_dir $h/test/perf | |
1263 | make_dir $h/test/pretty | |
1a4d82fc JJ |
1264 | make_dir $h/test/debuginfo-gdb |
1265 | make_dir $h/test/debuginfo-lldb | |
1266 | make_dir $h/test/codegen | |
9346a6ac | 1267 | make_dir $h/test/rustdoc |
223e47cc LB |
1268 | done |
1269 | ||
1270 | # Configure submodules | |
1271 | step_msg "configuring submodules" | |
1272 | ||
1273 | # Have to be in the top of src directory for this | |
1274 | if [ -z $CFG_DISABLE_MANAGE_SUBMODULES ] | |
1275 | then | |
1276 | cd ${CFG_SRC_DIR} | |
1277 | ||
1278 | msg "git: submodule sync" | |
1a4d82fc JJ |
1279 | "${CFG_GIT}" submodule sync |
1280 | ||
1281 | msg "git: submodule init" | |
1282 | "${CFG_GIT}" submodule init | |
1283 | ||
1284 | # Disable submodules that we're not using | |
1285 | if [ ! -z "${CFG_LLVM_ROOT}" ]; then | |
1286 | msg "git: submodule deinit src/llvm" | |
1287 | "${CFG_GIT}" submodule deinit src/llvm | |
1288 | fi | |
1289 | if [ ! -z "${CFG_JEMALLOC_ROOT}" ]; then | |
1290 | msg "git: submodule deinit src/jemalloc" | |
1291 | "${CFG_GIT}" submodule deinit src/jemalloc | |
1292 | fi | |
223e47cc LB |
1293 | |
1294 | msg "git: submodule update" | |
1a4d82fc | 1295 | "${CFG_GIT}" submodule update |
223e47cc LB |
1296 | need_ok "git failed" |
1297 | ||
1298 | msg "git: submodule foreach sync" | |
1a4d82fc | 1299 | "${CFG_GIT}" submodule foreach --recursive 'if test -e .gitmodules; then git submodule sync; fi' |
223e47cc LB |
1300 | need_ok "git failed" |
1301 | ||
1302 | msg "git: submodule foreach update" | |
1a4d82fc | 1303 | "${CFG_GIT}" submodule update --recursive |
223e47cc LB |
1304 | need_ok "git failed" |
1305 | ||
1306 | # NB: this is just for the sake of getting the submodule SHA1 values | |
1307 | # and status written into the build log. | |
1308 | msg "git: submodule status" | |
1309 | "${CFG_GIT}" submodule status --recursive | |
1310 | ||
1311 | msg "git: submodule clobber" | |
1a4d82fc | 1312 | "${CFG_GIT}" submodule foreach --recursive git clean -dxf |
223e47cc | 1313 | need_ok "git failed" |
1a4d82fc | 1314 | "${CFG_GIT}" submodule foreach --recursive git checkout . |
223e47cc LB |
1315 | need_ok "git failed" |
1316 | ||
1317 | cd ${CFG_BUILD_DIR} | |
1318 | fi | |
1319 | ||
1320 | # Configure llvm, only if necessary | |
1321 | step_msg "looking at LLVM" | |
1322 | CFG_LLVM_SRC_DIR=${CFG_SRC_DIR}src/llvm/ | |
1a4d82fc | 1323 | for t in $CFG_HOST |
223e47cc LB |
1324 | do |
1325 | do_reconfigure=1 | |
62682a34 SL |
1326 | is_msvc=0 |
1327 | case "$t" in | |
1328 | (*-msvc) | |
1329 | is_msvc=1 | |
1330 | ;; | |
1331 | esac | |
223e47cc LB |
1332 | |
1333 | if [ -z $CFG_LLVM_ROOT ] | |
1334 | then | |
1a4d82fc | 1335 | LLVM_BUILD_DIR=${CFG_BUILD_DIR}$t/llvm |
223e47cc LB |
1336 | if [ ! -z "$CFG_DISABLE_OPTIMIZE_LLVM" ] |
1337 | then | |
1338 | LLVM_DBG_OPTS="--enable-debug-symbols --disable-optimized" | |
1339 | # Just use LLVM straight from its build directory to | |
1340 | # avoid 'make install' time | |
1a4d82fc | 1341 | LLVM_INST_DIR=$LLVM_BUILD_DIR/Debug |
223e47cc LB |
1342 | else |
1343 | LLVM_DBG_OPTS="--enable-optimized" | |
1a4d82fc JJ |
1344 | LLVM_INST_DIR=$LLVM_BUILD_DIR/Release |
1345 | fi | |
9346a6ac | 1346 | if [ -z "$CFG_ENABLE_LLVM_ASSERTIONS" ] |
1a4d82fc JJ |
1347 | then |
1348 | LLVM_ASSERTION_OPTS="--disable-assertions" | |
1349 | else | |
1350 | LLVM_ASSERTION_OPTS="--enable-assertions" | |
62682a34 SL |
1351 | |
1352 | # Apparently even if we request assertions be enabled for MSVC, | |
1353 | # LLVM's CMake build system ignore this and outputs in `Release` | |
1354 | # anyway. | |
1355 | if [ ${is_msvc} -eq 0 ]; then | |
1356 | LLVM_INST_DIR=${LLVM_INST_DIR}+Asserts | |
1357 | fi | |
223e47cc LB |
1358 | fi |
1359 | else | |
1360 | msg "not reconfiguring LLVM, external LLVM root" | |
1361 | # The user is using their own LLVM | |
1362 | LLVM_BUILD_DIR= | |
1363 | LLVM_INST_DIR=$CFG_LLVM_ROOT | |
1364 | do_reconfigure=0 | |
1365 | fi | |
1366 | ||
1367 | ||
1368 | if [ ${do_reconfigure} -ne 0 ] | |
1369 | then | |
1370 | # because git is hilarious, it might have put the module index | |
1371 | # in a couple places. | |
1372 | index1="${CFG_SRC_DIR}.git/modules/src/llvm/index" | |
1373 | index2="${CFG_SRC_DIR}src/llvm/.git/index" | |
1374 | for index in ${index1} ${index2} | |
1375 | do | |
1a4d82fc | 1376 | config_status="${LLVM_BUILD_DIR}/config.status" |
223e47cc LB |
1377 | if test -e ${index} -a \ |
1378 | -e ${config_status} -a \ | |
1379 | ${config_status} -nt ${index} | |
1380 | then | |
1381 | msg "not reconfiguring LLVM, config.status is fresh" | |
1382 | do_reconfigure=0 | |
1383 | fi | |
1384 | done | |
1385 | fi | |
1386 | ||
62682a34 SL |
1387 | if [ ${do_reconfigure} -ne 0 ] && [ ${is_msvc} -ne 0 ] |
1388 | then | |
1389 | msg "configuring LLVM for $t with cmake" | |
1390 | ||
1391 | CMAKE_ARGS="-DLLVM_INCLUDE_TESTS=OFF" | |
1392 | if [ ! -z "$CFG_DISABLE_OPTIMIZE_LLVM" ]; then | |
1393 | CMAKE_ARGS="$CMAKE_ARGS -DCMAKE_BUILD_TYPE=Debug" | |
1394 | else | |
1395 | CMAKE_ARGS="$CMAKE_ARGS -DCMAKE_BUILD_TYPE=Release" | |
1396 | fi | |
1397 | if [ -z "$CFG_ENABLE_LLVM_ASSERTIONS" ] | |
1398 | then | |
1399 | CMAKE_ARGS="$CMAKE_ARGS -DLLVM_ENABLE_ASSERTIONS=OFF" | |
1400 | else | |
1401 | CMAKE_ARGS="$CMAKE_ARGS -DLLVM_ENABLE_ASSERTIONS=ON" | |
1402 | fi | |
1403 | ||
1404 | msg "configuring LLVM with:" | |
1405 | msg "$CMAKE_ARGS" | |
1406 | (cd $LLVM_BUILD_DIR && "$CFG_CMAKE" $CFG_LLVM_SRC_DIR \ | |
1407 | -G "Visual Studio 12 2013 Win64" \ | |
1408 | $CMAKE_ARGS) | |
1409 | need_ok "LLVM cmake configure failed" | |
1410 | fi | |
1411 | ||
1412 | if [ ${do_reconfigure} -ne 0 ] && [ ${is_msvc} -eq 0 ] | |
223e47cc | 1413 | then |
1a4d82fc JJ |
1414 | # LLVM's configure doesn't recognize the new Windows triples yet |
1415 | gnu_t=$(to_gnu_triple $t) | |
1416 | ||
1417 | msg "configuring LLVM for $gnu_t" | |
223e47cc | 1418 | |
85aaf69f | 1419 | LLVM_TARGETS="--enable-targets=x86,x86_64,arm,aarch64,mips,powerpc" |
1a4d82fc JJ |
1420 | LLVM_BUILD="--build=$gnu_t" |
1421 | LLVM_HOST="--host=$gnu_t" | |
1422 | LLVM_TARGET="--target=$gnu_t" | |
223e47cc LB |
1423 | |
1424 | # Disable unused LLVM features | |
1a4d82fc JJ |
1425 | LLVM_OPTS="$LLVM_DBG_OPTS $LLVM_ASSERTION_OPTS --disable-docs --enable-bindings=none" |
1426 | # Disable term-info, linkage of which comes in multiple forms, | |
1427 | # making our snapshots incompatible (#9334) | |
1428 | LLVM_OPTS="$LLVM_OPTS --disable-terminfo" | |
1429 | # Try to have LLVM pull in as few dependencies as possible (#9397) | |
1430 | LLVM_OPTS="$LLVM_OPTS --disable-zlib --disable-libffi" | |
1431 | ||
1432 | # Use win32 native thread/lock apis instead of pthread wrapper. | |
1433 | # (llvm's configure tries to find pthread first, so we have to disable it explicitly.) | |
1434 | # Also note that pthreads works badly on mingw-w64 systems: #8996 | |
1435 | case "$CFG_BUILD" in | |
62682a34 | 1436 | (*-windows-gnu) |
1a4d82fc JJ |
1437 | LLVM_OPTS="$LLVM_OPTS --disable-pthreads" |
1438 | ;; | |
1439 | esac | |
223e47cc | 1440 | |
1a4d82fc | 1441 | case "$CFG_CC" in |
970d7e83 | 1442 | ("ccache clang") |
1a4d82fc JJ |
1443 | LLVM_CXX_32="ccache clang++ -Qunused-arguments" |
1444 | LLVM_CC_32="ccache clang -Qunused-arguments" | |
970d7e83 LB |
1445 | |
1446 | LLVM_CXX_64="ccache clang++ -Qunused-arguments" | |
1447 | LLVM_CC_64="ccache clang -Qunused-arguments" | |
1448 | ;; | |
1449 | ("clang") | |
1a4d82fc JJ |
1450 | LLVM_CXX_32="clang++ -Qunused-arguments" |
1451 | LLVM_CC_32="clang -Qunused-arguments" | |
223e47cc | 1452 | |
1a4d82fc JJ |
1453 | LLVM_CXX_64="clang++ -Qunused-arguments" |
1454 | LLVM_CC_64="clang -Qunused-arguments" | |
970d7e83 LB |
1455 | ;; |
1456 | ("ccache gcc") | |
1a4d82fc JJ |
1457 | LLVM_CXX_32="ccache g++" |
1458 | LLVM_CC_32="ccache gcc" | |
970d7e83 LB |
1459 | |
1460 | LLVM_CXX_64="ccache g++" | |
1461 | LLVM_CC_64="ccache gcc" | |
1462 | ;; | |
1463 | ("gcc") | |
1a4d82fc JJ |
1464 | LLVM_CXX_32="g++" |
1465 | LLVM_CC_32="gcc" | |
223e47cc LB |
1466 | |
1467 | LLVM_CXX_64="g++" | |
1468 | LLVM_CC_64="gcc" | |
1a4d82fc JJ |
1469 | ;; |
1470 | ||
1471 | (*) | |
1472 | msg "inferring LLVM_CXX/CC from CXX/CC = $CXX/$CC" | |
1473 | LLVM_CXX_32="$CXX" | |
1474 | LLVM_CC_32="$CC" | |
1475 | ||
1476 | LLVM_CXX_64="$CXX" | |
1477 | LLVM_CC_64="$CC" | |
1478 | ;; | |
970d7e83 | 1479 | esac |
223e47cc | 1480 | |
1a4d82fc JJ |
1481 | case "$CFG_CPUTYPE" in |
1482 | (x86*) | |
1483 | LLVM_CXX_32="$LLVM_CXX_32 -m32" | |
1484 | LLVM_CC_32="$LLVM_CC_32 -m32" | |
1485 | ||
1486 | LLVM_CFLAGS_32="-m32" | |
1487 | LLVM_CXXFLAGS_32="-m32" | |
1488 | LLVM_LDFLAGS_32="-m32" | |
223e47cc | 1489 | |
1a4d82fc JJ |
1490 | LLVM_CFLAGS_64="" |
1491 | LLVM_CXXFLAGS_64="" | |
1492 | LLVM_LDFLAGS_64="" | |
1493 | ||
1494 | LLVM_CXX_32="$LLVM_CXX_32 -m32" | |
1495 | LLVM_CC_32="$LLVM_CC_32 -m32" | |
1496 | ;; | |
1497 | ||
1498 | (*) | |
1499 | LLVM_CFLAGS_32="" | |
1500 | LLVM_CXXFLAGS_32="" | |
1501 | LLVM_LDFLAGS_32="" | |
1502 | ||
1503 | LLVM_CFLAGS_64="" | |
1504 | LLVM_CXXFLAGS_64="" | |
1505 | LLVM_LDFLAGS_64="" | |
1506 | ;; | |
1507 | esac | |
223e47cc LB |
1508 | |
1509 | if echo $t | grep -q x86_64 | |
1510 | then | |
1511 | LLVM_CXX=$LLVM_CXX_64 | |
1512 | LLVM_CC=$LLVM_CC_64 | |
1513 | LLVM_CFLAGS=$LLVM_CFLAGS_64 | |
1514 | LLVM_CXXFLAGS=$LLVM_CXXFLAGS_64 | |
1515 | LLVM_LDFLAGS=$LLVM_LDFLAGS_64 | |
1516 | else | |
1517 | LLVM_CXX=$LLVM_CXX_32 | |
1518 | LLVM_CC=$LLVM_CC_32 | |
1519 | LLVM_CFLAGS=$LLVM_CFLAGS_32 | |
1520 | LLVM_CXXFLAGS=$LLVM_CXXFLAGS_32 | |
1521 | LLVM_LDFLAGS=$LLVM_LDFLAGS_32 | |
1522 | fi | |
1523 | ||
1524 | CXX=$LLVM_CXX | |
1525 | CC=$LLVM_CC | |
1526 | CFLAGS=$LLVM_CFLAGS | |
1527 | CXXFLAGS=$LLVM_CXXFLAGS | |
1528 | LDFLAGS=$LLVM_LDFLAGS | |
1529 | ||
1a4d82fc JJ |
1530 | if [ -z "$CFG_DISABLE_LIBCPP" ] && [ -n "$CFG_USING_CLANG" ]; then |
1531 | LLVM_OPTS="$LLVM_OPTS --enable-libcpp" | |
1532 | fi | |
1533 | ||
223e47cc | 1534 | LLVM_FLAGS="$LLVM_TARGETS $LLVM_OPTS $LLVM_BUILD \ |
970d7e83 | 1535 | $LLVM_HOST $LLVM_TARGET --with-python=$CFG_PYTHON" |
223e47cc LB |
1536 | |
1537 | msg "configuring LLVM with:" | |
1538 | msg "$LLVM_FLAGS" | |
1539 | ||
1540 | export CXX | |
1541 | export CC | |
1542 | export CFLAGS | |
1543 | export CXXFLAGS | |
1544 | export LDFLAGS | |
1545 | ||
1546 | cd $LLVM_BUILD_DIR | |
1547 | case $CFG_SRC_DIR in | |
1548 | /* | [a-z]:* | [A-Z]:*) | |
1549 | ${CFG_LLVM_SRC_DIR}configure $LLVM_FLAGS | |
1550 | ;; | |
1551 | *) | |
1552 | ${CFG_BUILD_DIR}${CFG_LLVM_SRC_DIR}configure \ | |
1553 | $LLVM_FLAGS | |
1554 | ;; | |
1555 | esac | |
1556 | need_ok "LLVM configure failed" | |
1557 | ||
223e47cc LB |
1558 | cd $CFG_BUILD_DIR |
1559 | fi | |
1560 | ||
1561 | # Construct variables for LLVM build and install directories for | |
1562 | # each target. These will be named | |
1563 | # CFG_LLVM_BUILD_DIR_${target_triple} but all the hyphens in | |
1564 | # target_triple will be converted to underscore, because bash | |
1565 | # variables can't contain hyphens. The makefile will then have to | |
1566 | # convert back. | |
1567 | CFG_LLVM_BUILD_DIR=$(echo CFG_LLVM_BUILD_DIR_${t} | tr - _) | |
1568 | CFG_LLVM_INST_DIR=$(echo CFG_LLVM_INST_DIR_${t} | tr - _) | |
1569 | eval ${CFG_LLVM_BUILD_DIR}="'$LLVM_BUILD_DIR'" | |
1570 | eval ${CFG_LLVM_INST_DIR}="'$LLVM_INST_DIR'" | |
1571 | done | |
1572 | ||
1573 | ||
1574 | step_msg "writing configuration" | |
1575 | ||
1576 | putvar CFG_SRC_DIR | |
62682a34 | 1577 | putvar CFG_SRC_DIR_RELATIVE |
223e47cc LB |
1578 | putvar CFG_BUILD_DIR |
1579 | putvar CFG_OSTYPE | |
1580 | putvar CFG_CPUTYPE | |
1581 | putvar CFG_CONFIGURE_ARGS | |
1582 | putvar CFG_PREFIX | |
1a4d82fc JJ |
1583 | putvar CFG_HOST |
1584 | putvar CFG_TARGET | |
1585 | putvar CFG_LIBDIR_RELATIVE | |
223e47cc LB |
1586 | putvar CFG_DISABLE_MANAGE_SUBMODULES |
1587 | putvar CFG_ANDROID_CROSS_PATH | |
1a4d82fc | 1588 | putvar CFG_MANDIR |
223e47cc | 1589 | |
970d7e83 LB |
1590 | # Avoid spurious warnings from clang by feeding it original source on |
1591 | # ccache-miss rather than preprocessed input. | |
1a4d82fc | 1592 | if [ ! -z "$CFG_ENABLE_CCACHE" ] && [ ! -z "$CFG_USING_CLANG" ] |
970d7e83 LB |
1593 | then |
1594 | CFG_CCACHE_CPP2=1 | |
1595 | putvar CFG_CCACHE_CPP2 | |
1596 | fi | |
1597 | ||
1598 | if [ ! -z "$CFG_ENABLE_CCACHE" ] | |
1599 | then | |
1600 | CFG_CCACHE_BASEDIR=${CFG_SRC_DIR} | |
1601 | putvar CFG_CCACHE_BASEDIR | |
1602 | fi | |
1603 | ||
1604 | ||
223e47cc LB |
1605 | if [ ! -z $BAD_PANDOC ] |
1606 | then | |
1607 | CFG_PANDOC= | |
1608 | putvar CFG_PANDOC | |
1609 | fi | |
1610 | ||
223e47cc LB |
1611 | putvar CFG_LLVM_SRC_DIR |
1612 | ||
1a4d82fc | 1613 | for t in $CFG_HOST |
223e47cc LB |
1614 | do |
1615 | CFG_LLVM_BUILD_DIR=$(echo CFG_LLVM_BUILD_DIR_${t} | tr - _) | |
1616 | CFG_LLVM_INST_DIR=$(echo CFG_LLVM_INST_DIR_${t} | tr - _) | |
1617 | putvar $CFG_LLVM_BUILD_DIR | |
1618 | putvar $CFG_LLVM_INST_DIR | |
1619 | done | |
1620 | ||
223e47cc LB |
1621 | msg |
1622 | copy_if_changed ${CFG_SRC_DIR}Makefile.in ./Makefile | |
1623 | move_if_changed config.tmp config.mk | |
1624 | rm -f config.tmp | |
1625 | touch config.stamp | |
1626 | ||
9346a6ac AL |
1627 | if [ -z "$CFG_ENABLE_DEBUG" ]; then |
1628 | step_msg "configured in release mode. for development consider --enable-debug" | |
1629 | else | |
1630 | step_msg "complete" | |
1631 | fi | |
1632 | ||
1a4d82fc JJ |
1633 | msg "run \`make help\`" |
1634 | msg |