configure

   1 #!/bin/sh
   2
   3 msg() {
   4     echo "configure: $1"
   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
  22 need_ok() {
  23     if [ $? -ne 0 ]
  24     then
  25         err $1
  26     fi
  27 }
  28
  29 need_cmd() {
  30     if which $1 >/dev/null 2>&1
  31     then msg "found $1"
  32     else err "need $1"
  33     fi
  34 }
  35
  36 make_dir() {
  37     if [ ! -d $1 ]
  38     then
  39         msg "mkdir -p $1"
  40         mkdir -p $1
  41     fi
  42 }
  43
  44 copy_if_changed() {
  45     if cmp -s $1 $2
  46     then
  47         msg "leaving $2 unchanged"
  48     else
  49         msg "cp $1 $2"
  50         cp -f $1 $2
  51         chmod u-w $2 # make copied artifact read-only
  52     fi
  53 }
  54
  55 move_if_changed() {
  56     if cmp -s $1 $2
  57     then
  58         msg "leaving $2 unchanged"
  59     else
  60         msg "mv $1 $2"
  61         mv -f $1 $2
  62         chmod u-w $2 # make moved artifact read-only
  63     fi
  64 }
  65
  66 putvar() {
  67     local T
  68     eval T=\$$1
  69     eval TLEN=\${#$1}
  70     if [ $TLEN -gt 35 ]
  71     then
  72         printf "configure: %-20s := %.35s ...\n" $1 "$T"
  73     else
  74         printf "configure: %-20s := %s %s\n" $1 "$T" "$2"
  75     fi
  76     printf "%-20s := %s\n" $1 "$T" >>config.tmp
  77 }
  78
  79 probe() {
  80     local V=$1
  81     shift
  82     local P
  83     local T
  84     for P
  85     do
  86         T=$(which $P 2>&1)
  87         if [ $? -eq 0 ]
  88         then
  89             VER0=$($P --version 2>/dev/null | head -1 \
  90                 |  sed -e 's/[^0-9]*\([vV]\?[0-9.]\+[^ ]*\).*/\1/' )
  91             if [ $? -eq 0 -a "x${VER0}" != "x" ]
  92             then
  93               VER="($VER0)"
  94             else
  95               VER=""
  96             fi
  97             break
  98         else
  99             VER=""
 100             T=""
 101         fi
 102     done
 103     eval $V=\$T
 104     putvar $V "$VER"
 105 }
 106
 107 probe_need() {
 108     local V=$1
 109     probe $*
 110     eval VV=\$$V
 111     if [ -z "$VV" ]
 112     then
 113         err "needed, but unable to find any of: $*"
 114     fi
 115 }
 116
 117 validate_opt () {
 118     for arg in $CFG_CONFIGURE_ARGS
 119     do
 120         isArgValid=0
 121         for option in $BOOL_OPTIONS
 122         do
 123             if test --disable-$option = $arg
 124             then
 125                 isArgValid=1
 126             fi
 127             if test --enable-$option = $arg
 128             then
 129                 isArgValid=1
 130             fi
 131         done
 132         for option in $VAL_OPTIONS
 133         do
 134             if echo "$arg" | grep -q -- "--$option="
 135             then
 136                 isArgValid=1
 137             fi
 138         done
 139         if [ "$arg" = "--help" ]
 140         then
 141             echo ""
 142             echo "No more help available for Configure options,"
 143             echo "check the Wiki or join our IRC channel"
 144             break
 145         else
 146             if test $isArgValid -eq 0
 147             then
 148                 err "Option '$arg' is not recognized"
 149             fi
 150         fi
 151     done
 152 }
 153
 154 valopt() {
 155     VAL_OPTIONS="$VAL_OPTIONS $1"
 156
 157     local OP=$1
 158     local DEFAULT=$2
 159     shift
 160     shift
 161     local DOC="$*"
 162     if [ $HELP -eq 0 ]
 163     then
 164         local UOP=$(echo $OP | tr '[:lower:]' '[:upper:]' | tr '\-' '\_')
 165         local V="CFG_${UOP}"
 166         eval $V="$DEFAULT"
 167         for arg in $CFG_CONFIGURE_ARGS
 168         do
 169             if echo "$arg" | grep -q -- "--$OP="
 170             then
 171                 val=$(echo "$arg" | cut -f2 -d=)
 172                 eval $V=$val
 173             fi
 174         done
 175         putvar $V
 176     else
 177         if [ -z "$DEFAULT" ]
 178         then
 179             DEFAULT="<none>"
 180         fi
 181         OP="${OP}=[${DEFAULT}]"
 182         printf "    --%-30s %s\n" "$OP" "$DOC"
 183     fi
 184 }
 185
 186 opt() {
 187     BOOL_OPTIONS="$BOOL_OPTIONS $1"
 188
 189     local OP=$1
 190     local DEFAULT=$2
 191     shift
 192     shift
 193     local DOC="$*"
 194     local FLAG=""
 195
 196     if [ $DEFAULT -eq 0 ]
 197     then
 198         FLAG="enable"
 199     else
 200         FLAG="disable"
 201         DOC="don't $DOC"
 202     fi
 203
 204     if [ $HELP -eq 0 ]
 205     then
 206         for arg in $CFG_CONFIGURE_ARGS
 207         do
 208             if [ "$arg" = "--${FLAG}-${OP}" ]
 209             then
 210                 OP=$(echo $OP | tr 'a-z-' 'A-Z_')
 211                 FLAG=$(echo $FLAG | tr 'a-z' 'A-Z')
 212                 local V="CFG_${FLAG}_${OP}"
 213                 eval $V=1
 214                 putvar $V
 215             fi
 216         done
 217     else
 218         if [ ! -z "$META" ]
 219         then
 220             OP="$OP=<$META>"
 221         fi
 222         printf "    --%-30s %s\n" "$FLAG-$OP" "$DOC"
 223      fi
 224 }
 225
 226 msg "looking for configure programs"
 227 need_cmd cmp
 228 need_cmd mkdir
 229 need_cmd printf
 230 need_cmd cut
 231 need_cmd head
 232 need_cmd grep
 233 need_cmd xargs
 234 need_cmd cp
 235 need_cmd find
 236 need_cmd uname
 237 need_cmd date
 238 need_cmd tr
 239 need_cmd sed
 240
 241
 242 msg "inspecting environment"
 243
 244 CFG_OSTYPE=$(uname -s)
 245 CFG_CPUTYPE=$(uname -m)
 246
 247 if [ $CFG_OSTYPE = Darwin -a $CFG_CPUTYPE = i386 ]
 248 then
 249     # Darwin's `uname -s` lies and always returns i386. We have to use sysctl
 250     # instead.
 251     if sysctl hw.optional.x86_64 | grep -q ': 1'
 252     then
 253         CFG_CPUTYPE=x86_64
 254     fi
 255 fi
 256
 257 # The goal here is to come up with the same triple as LLVM would,
 258 # at least for the subset of platforms we're willing to target.
 259
 260 case $CFG_OSTYPE in
 261
 262     Linux)
 263         CFG_OSTYPE=unknown-linux-gnu
 264         ;;
 265
 266     FreeBSD)
 267         CFG_OSTYPE=unknown-freebsd
 268         ;;
 269
 270     Darwin)
 271         CFG_OSTYPE=apple-darwin
 272         ;;
 273
 274     MINGW32*)
 275         CFG_OSTYPE=pc-mingw32
 276         ;;
 277 # Thad's Cygwin identifers below
 278
 279 #   Vista 32 bit
 280     CYGWIN_NT-6.0)
 281         CFG_OSTYPE=pc-mingw32
 282         CFG_CPUTYPE=i686
 283         ;;
 284
 285 #   Vista 64 bit
 286     CYGWIN_NT-6.0-WOW64)
 287         CFG_OSTYPE=w64-mingw32
 288         CFG_CPUTYPE=x86_64
 289         ;;
 290
 291 #   Win 7 32 bit
 292     CYGWIN_NT-6.1)
 293         CFG_OSTYPE=pc-mingw32
 294         CFG_CPUTYPE=i686
 295         ;;
 296
 297 #   Win 7 64 bit
 298     CYGWIN_NT-6.1-WOW64)
 299         CFG_OSTYPE=w64-mingw32
 300         CFG_CPUTYPE=x86_64
 301         ;;
 302
 303 # We do not detect other OS such as XP/2003 using 64 bit using uname.
 304 # 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.
 305     *)
 306         err "unknown OS type: $CFG_OSTYPE"
 307         ;;
 308 esac
 309
 310
 311 if [ -z "$CFG_CPUTYPE" ]
 312 then
 313 case $CFG_CPUTYPE in
 314
 315     i386 | i486 | i686 | i786 | x86)
 316         CFG_CPUTYPE=i686
 317         ;;
 318
 319     xscale | arm)
 320         CFG_CPUTYPE=arm
 321         ;;
 322
 323     x86_64 | x86-64 | x64 | amd64)
 324         CFG_CPUTYPE=x86_64
 325         ;;
 326
 327     *)
 328         err "unknown CPU type: $CFG_CPUTYPE"
 329 esac
 330 fi
 331
 332 # Detect 64 bit linux systems with 32 bit userland and force 32 bit compilation
 333 if [ $CFG_OSTYPE = unknown-linux-gnu -a $CFG_CPUTYPE = x86_64 ]
 334 then
 335     file -L "$SHELL" | grep -q "x86[_-]64"
 336     if [ $? != 0 ]; then
 337         CFG_CPUTYPE=i686
 338     fi
 339 fi
 340
 341
 342 DEFAULT_BUILD_TRIPLE="${CFG_CPUTYPE}-${CFG_OSTYPE}"
 343
 344 CFG_SRC_DIR="$(cd $(dirname $0) && pwd)/"
 345 CFG_BUILD_DIR="$(pwd)/"
 346 CFG_SELF=${CFG_SRC_DIR}$(basename $0)
 347 CFG_CONFIGURE_ARGS="$@"
 348
 349 OPTIONS=""
 350 HELP=0
 351 if [ "$1" = "--help" ]
 352 then
 353     HELP=1
 354     shift
 355     echo ""
 356     echo "Usage: $CFG_SELF [options]"
 357     echo ""
 358     echo "Options:"
 359     echo ""
 360 else
 361     msg "recreating config.tmp"
 362     echo '' >config.tmp
 363
 364     step_msg "processing $CFG_SELF args"
 365 fi
 366
 367 BOOL_OPTIONS=""
 368 VAL_OPTIONS=""
 369
 370 opt sharedstd 1 "build libstd as a shared library"
 371 opt valgrind 0 "run tests with valgrind (memcheck by default)"
 372 opt helgrind 0 "run tests with helgrind instead of memcheck"
 373 opt docs     1 "build documentation"
 374 opt optimize 1 "build optimized rust code"
 375 opt optimize-cxx 1 "build optimized C++ code"
 376 opt optimize-llvm 1 "build optimized LLVM"
 377 opt debug 0 "build with extra debug fun"
 378 opt fast-make 0 "use .gitmodules as timestamp for submodule deps"
 379 opt manage-submodules 1 "let the build manage the git submodules"
 380 opt mingw-cross 0 "cross-compile for win32 using mingw"
 381 opt clang 0 "prefer clang to gcc for building the runtime"
 382 opt local-rust 0 "use an installed rustc rather than downloading a snapshot"
 383 opt pax-flags 0 "apply PaX flags to rustc binaries (required for GRSecurity/PaX-patched kernels)"
 384 valopt prefix "/usr/local" "set installation prefix"
 385 valopt local-rust-root "/usr/local" "set prefix for local rust binary"
 386 valopt llvm-root "" "set LLVM root"
 387 valopt build-triple "${DEFAULT_BUILD_TRIPLE}" "LLVM build triple"
 388 valopt host-triples "${CFG_BUILD_TRIPLE}" "LLVM host triples"
 389 valopt target-triples "${CFG_HOST_TRIPLES}" "LLVM target triples"
 390 valopt android-cross-path "/opt/ndk_standalone" "Android NDK standalone path"
 391 valopt mingw32-cross-path "" "MinGW32 cross compiler path"
 392
 393 # Validate Options
 394 step_msg "validating $CFG_SELF args"
 395 validate_opt
 396
 397 if [ $HELP -eq 1 ]
 398 then
 399     echo ""
 400     exit 0
 401 fi
 402
 403
 404 step_msg "looking for build programs"
 405
 406 probe_need CFG_PERL        perl
 407 probe_need CFG_CURL        curl
 408 probe_need CFG_PYTHON      python2.7 python2.6 python2 python
 409
 410 python_version=$($CFG_PYTHON -V 2>&1)
 411 if [ $(echo $python_version | grep -c '^Python 2\.[4567]') -ne 1 ]; then
 412     err "Found $python_version, but LLVM requires Python 2.4-2.7"
 413 fi
 414
 415 # If we have no git directory then we are probably a tarball distribution
 416 # and shouldn't attempt to load submodules
 417 if [ ! -e ${CFG_SRC_DIR}.git ]
 418 then
 419     probe CFG_GIT          git
 420     msg "git: no git directory. disabling submodules"
 421     CFG_DISABLE_MANAGE_SUBMODULES=1
 422 else
 423     probe_need CFG_GIT     git
 424 fi
 425
 426 probe CFG_CLANG            clang++
 427 probe CFG_GCC              gcc
 428 probe CFG_LD               ld
 429 probe CFG_VALGRIND         valgrind
 430 probe CFG_PERF             perf
 431 probe CFG_ISCC             iscc
 432 probe CFG_LLNEXTGEN        LLnextgen
 433 probe CFG_PANDOC           pandoc
 434 probe CFG_PDFLATEX         pdflatex
 435 probe CFG_XETEX            xetex
 436 probe CFG_LUATEX           luatex
 437 probe CFG_NODE             nodejs node
 438 probe CFG_GDB              gdb
 439 if [ "$CFG_OSTYPE" = "unknown-linux-gnu" ]
 440 then
 441     probe CFG_PAXCTL           paxctl /sbin/paxctl
 442     probe CFG_ZCAT             zcat
 443 fi
 444
 445 if [ ! -z "$CFG_PANDOC" ]
 446 then
 447     PV_MAJOR_MINOR=$(pandoc --version | grep '^pandoc ' |
 448         # extract the first 2 version fields, ignore everything else
 449         sed 's/pandoc \([0-9]*\)\.\([0-9]*\).*/\1 \2/')
 450
 451     # these patterns are shell globs, *not* regexps
 452     PV_MAJOR=${PV_MAJOR_MINOR% *}
 453     PV_MINOR=${PV_MAJOR_MINOR#* }
 454     if [ "$PV_MAJOR" -lt "1" ] || [ "$PV_MINOR" -lt "8" ]
 455     then
 456                 step_msg "pandoc $PV_MAJOR.$PV_MINOR is too old. disabling"
 457                 BAD_PANDOC=1
 458     fi
 459 fi
 460
 461 if [ "$CFG_OSTYPE" = "unknown-linux-gnu" ]
 462 then
 463     if [ ! -z "$CFG_ENABLE_PAX_FLAGS" -a -z "$CFG_PAXCTL" ]
 464     then
 465         err "enabled PaX markings but no paxctl binary found"
 466     fi
 467
 468     if [ -z "$CFG_DISABLE_PAX_FLAGS" ]
 469     then
 470         # GRSecurity/PaX detection. This can be very flaky.
 471         GRSEC_DETECTED=
 472
 473         # /dev/grsec only exists if CONFIG_GRKERNSEC_NO_RBAC is not set.
 474         # /proc/sys/kernel/grsecurity is not available if ÇONFIG_GRKERNSEC_SYSCTL is not set.
 475         if [ -e /dev/grsec -o -d /proc/sys/kernel/grsecurity ]
 476         then
 477             GRSEC_DETECTED=1
 478         # /proc/config.gz is normally only available to root, and only if CONFIG_IKCONFIG_PROC has been set.
 479         elif [ -r /proc/config.gz -a ! -z "$CFG_ZCAT" ]
 480         then
 481             if "$CFG_ZCAT" /proc/config.gz | grep --quiet "CONFIG_GRKERNSEC=y"
 482             then
 483                 GRSEC_DETECTED=1
 484             fi
 485         # Flaky.
 486         elif grep --quiet grsec /proc/version
 487         then
 488             GRSEC_DETECTED=1
 489         fi
 490
 491         if [ ! -z "$GRSEC_DETECTED" ]
 492         then
 493             step_msg "GRSecurity: yes"
 494             if [ ! -z "$CFG_PAXCTL" ]
 495             then
 496                 CFG_ENABLE_PAX_FLAGS=1
 497             else
 498                 warn "GRSecurity kernel detected but no paxctl binary found: not setting CFG_ENABLE_PAX_FLAGS"
 499             fi
 500         else
 501             step_msg "GRSecurity: no"
 502         fi
 503     fi
 504 fi
 505
 506 if [ ! -z "$CFG_ENABLE_LOCAL_RUST" ]
 507 then
 508     if [ ! -f ${CFG_LOCAL_RUST_ROOT}/bin/rustc ]
 509     then
 510         err "no local rust to use"
 511     else
 512         LRV=`${CFG_LOCAL_RUST_ROOT}/bin/rustc --version`
 513         step_msg "using rustc at: ${CFG_LOCAL_RUST_ROOT} with version: " $LRV
 514     fi
 515 fi
 516
 517 # Force freebsd to build with clang; gcc doesn't like us there
 518 if [ $CFG_OSTYPE = unknown-freebsd ]
 519 then
 520     step_msg "on FreeBSD, forcing use of clang"
 521     CFG_ENABLE_CLANG=1
 522     putvar CFG_ENABLE_CLANG
 523 fi
 524
 525
 526 if [ -z "$CFG_ENABLE_CLANG" -a -z "$CFG_GCC" ]
 527 then
 528     err "either clang or gcc is required"
 529 fi
 530
 531 if [ ! -z "$CFG_LLVM_ROOT" -a -e "$CFG_LLVM_ROOT/bin/llvm-config" ]
 532 then
 533     step_msg "using custom LLVM at $CFG_LLVM_ROOT"
 534
 535     LLVM_CONFIG="$CFG_LLVM_ROOT/bin/llvm-config"
 536     LLVM_VERSION=$($LLVM_CONFIG --version)
 537
 538     case $LLVM_VERSION in
 539         (3.1svn|3.1|3.0svn|3.0)
 540             msg "found ok version of LLVM: $LLVM_VERSION"
 541             ;;
 542         (*)
 543             err "bad LLVM version: $LLVM_VERSION, need >=3.0svn"
 544             ;;
 545     esac
 546 fi
 547
 548 if [ ! -z "$CFG_ENABLE_CLANG" ]
 549 then
 550     if [ -z "$CFG_CLANG" ]
 551     then
 552         err "clang requested but not found"
 553     fi
 554     CFG_CLANG_VERSION=$("$CFG_CLANG" \
 555                       --version \
 556                       | grep version \
 557                       | sed 's/.*\(version .*\)/\1/' \
 558                       | cut -d ' ' -f 2)
 559
 560     case $CFG_CLANG_VERSION in
 561         (3.0svn | 3.0 | 3.1* | 3.2* | 3.3* | 4.0* | 4.1* | 4.2*)
 562         step_msg "found ok version of CLANG: $CFG_CLANG_VERSION"
 563         CFG_C_COMPILER="clang"
 564         ;;
 565         (*)
 566         err "bad CLANG version: $CFG_CLANG_VERSION, need >=3.0svn"
 567         ;;
 568     esac
 569 else
 570     CFG_C_COMPILER="gcc"
 571 fi
 572
 573 # a little post-processing of various config values
 574
 575 CFG_PREFIX=${CFG_PREFIX%/}
 576 CFG_HOST_TRIPLES="$(echo $CFG_HOST_TRIPLES | tr ',' ' ')"
 577 CFG_TARGET_TRIPLES="$(echo $CFG_TARGET_TRIPLES | tr ',' ' ')"
 578 CFG_SUPPORTED_TARGET_TRIPLES="$(grep ^CC_*=* $CFG_SRC_DIR/mk/platform.mk | sed 's,^[^_]*_,,' | sed 's/\([^=]*\).*/\1/' | xargs)"
 579
 580 # copy host-triples to target-triples so that hosts are a subset of targets
 581 V_TEMP=""
 582 for i in $CFG_HOST_TRIPLES $CFG_TARGET_TRIPLES;
 583 do
 584    echo "$V_TEMP" | grep -qF $i || V_TEMP="$V_TEMP${V_TEMP:+ }$i"
 585 done
 586 CFG_TARGET_TRIPLES=$V_TEMP
 587
 588 # check target-specific tool-chains
 589 for i in $CFG_TARGET_TRIPLES
 590 do
 591     L_CHECK=false
 592     for j in $CFG_SUPPORTED_TARGET_TRIPLES
 593     do
 594         if [ $i = $j ]
 595         then
 596             L_CHECK=true
 597         fi
 598     done
 599
 600     if [ $L_CHECK = false ]
 601     then
 602         err "unsupported target triples \"$i\" found"
 603     fi
 604
 605     case $i in
 606         arm-linux-androideabi)
 607
 608             if [ ! -f $CFG_ANDROID_CROSS_PATH/bin/arm-linux-androideabi-gcc ]
 609             then
 610                 err "NDK $CFG_ANDROID_CROSS_PATH/bin/arm-linux-androideabi-gcc not found"
 611             fi
 612             if [ ! -f $CFG_ANDROID_CROSS_PATH/bin/arm-linux-androideabi-g++ ]
 613             then
 614                 err "NDK $CFG_ANDROID_CROSS_PATH/bin/arm-linux-androideabi-g++ not found"
 615             fi
 616             if [ ! -f $CFG_ANDROID_CROSS_PATH/bin/arm-linux-androideabi-ar ]
 617             then
 618                 err "NDK $CFG_ANDROID_CROSS_PATH/bin/arm-linux-androideabi-ar not found"
 619             fi
 620             ;;
 621
 622         *)
 623             ;;
 624     esac
 625 done
 626
 627 if [ -z "$CFG_ENABLE_CLANG" -a -z "$CFG_GCC" ]
 628 then
 629     err "either clang or gcc is required"
 630 fi
 631
 632 if [ ! -z "$CFG_PERF" ]
 633 then
 634     HAVE_PERF_LOGFD=`$CFG_PERF stat --log-fd 2>&1 | grep 'unknown option'`
 635     if [ -z "$HAVE_PERF_LOGFD" ];
 636     then
 637         CFG_PERF_WITH_LOGFD=1
 638         putvar CFG_PERF_WITH_LOGFD
 639     fi
 640 fi
 641
 642 step_msg "making directories"
 643
 644 for i in \
 645     doc doc/core doc/std \
 646     dl tmp
 647 do
 648     make_dir $i
 649 done
 650
 651 make_dir llvm
 652 for t in $CFG_HOST_TRIPLES
 653 do
 654     make_dir llvm/$t
 655 done
 656
 657 make_dir rustllvm
 658 for t in $CFG_HOST_TRIPLES
 659 do
 660     make_dir rustllvm/$t
 661 done
 662
 663 make_dir rt
 664 for t in $CFG_TARGET_TRIPLES
 665 do
 666   make_dir rt/$t
 667   for i in                                          \
 668     isaac linenoise sync test \
 669     arch/i386 arch/x86_64 arch/arm arch/mips  \
 670     libuv libuv/src/ares libuv/src/eio libuv/src/ev
 671   do
 672     make_dir rt/$t/$i
 673   done
 674 done
 675
 676 # On windows we just store the libraries in the bin directory because
 677 # there's no rpath
 678 # FIXME: Thise needs to parameterized over target triples. Do it in platform.mk
 679 CFG_LIBDIR=lib
 680 if [ "$CFG_OSTYPE" = "pc-mingw32" ]
 681 then
 682     CFG_LIBDIR=bin
 683 fi
 684
 685 for h in $CFG_HOST_TRIPLES
 686 do
 687     for t in $CFG_TARGET_TRIPLES
 688     do
 689         for i in 0 1 2 3
 690         do
 691             # host bin dir
 692             make_dir $h/stage$i/bin
 693
 694             # host lib dir
 695             make_dir $h/stage$i/$CFG_LIBDIR
 696
 697             # target bin dir
 698             make_dir $h/stage$i/$CFG_LIBDIR/rustc/$t/bin
 699
 700             # target lib dir
 701             make_dir $h/stage$i/$CFG_LIBDIR/rustc/$t/$CFG_LIBDIR
 702         done
 703     done
 704
 705     make_dir $h/test/run-pass
 706     make_dir $h/test/run-pass-fulldeps
 707     make_dir $h/test/run-fail
 708     make_dir $h/test/compile-fail
 709     make_dir $h/test/bench
 710     make_dir $h/test/perf
 711     make_dir $h/test/pretty
 712     make_dir $h/test/debug-info
 713     make_dir $h/test/doc-tutorial
 714     make_dir $h/test/doc-tutorial-ffi
 715     make_dir $h/test/doc-tutorial-macros
 716     make_dir $h/test/doc-tutorial-borrowed-ptr
 717     make_dir $h/test/doc-tutorial-tasks
 718     make_dir $h/test/doc-rust
 719 done
 720
 721 # Configure submodules
 722 step_msg "configuring submodules"
 723
 724 # Have to be in the top of src directory for this
 725 if [ -z $CFG_DISABLE_MANAGE_SUBMODULES ]
 726 then
 727     cd ${CFG_SRC_DIR}
 728
 729     msg "git: submodule sync"
 730     "${CFG_GIT}" submodule --quiet sync
 731
 732     msg "git: submodule update"
 733     "${CFG_GIT}" submodule --quiet update --init
 734     need_ok "git failed"
 735
 736     msg "git: submodule foreach sync"
 737     "${CFG_GIT}" submodule --quiet foreach --recursive 'if test -e .gitmodules; then git submodule sync; fi'
 738     need_ok "git failed"
 739
 740     msg "git: submodule foreach update"
 741     "${CFG_GIT}" submodule --quiet update --init --recursive
 742     need_ok "git failed"
 743
 744     # NB: this is just for the sake of getting the submodule SHA1 values
 745     # and status written into the build log.
 746     msg "git: submodule status"
 747     "${CFG_GIT}" submodule status --recursive
 748
 749     msg "git: submodule clobber"
 750     "${CFG_GIT}" submodule --quiet foreach --recursive git clean -dxf
 751     need_ok "git failed"
 752     "${CFG_GIT}" submodule --quiet foreach --recursive git checkout .
 753     need_ok "git failed"
 754
 755     cd ${CFG_BUILD_DIR}
 756 fi
 757
 758 # Configure llvm, only if necessary
 759 step_msg "looking at LLVM"
 760 CFG_LLVM_SRC_DIR=${CFG_SRC_DIR}src/llvm/
 761 for t in $CFG_HOST_TRIPLES
 762 do
 763     do_reconfigure=1
 764
 765     if [ -z $CFG_LLVM_ROOT ]
 766     then
 767         LLVM_BUILD_DIR=${CFG_BUILD_DIR}llvm/$t
 768         if [ ! -z "$CFG_DISABLE_OPTIMIZE_LLVM" ]
 769         then
 770             LLVM_DBG_OPTS="--enable-debug-symbols --disable-optimized"
 771             # Just use LLVM straight from its build directory to
 772             # avoid 'make install' time
 773             LLVM_INST_DIR=$LLVM_BUILD_DIR/Debug+Asserts
 774         else
 775             LLVM_DBG_OPTS="--enable-optimized"
 776             LLVM_INST_DIR=$LLVM_BUILD_DIR/Release+Asserts
 777         fi
 778     else
 779         msg "not reconfiguring LLVM, external LLVM root"
 780         # The user is using their own LLVM
 781         LLVM_BUILD_DIR=
 782         LLVM_INST_DIR=$CFG_LLVM_ROOT
 783         do_reconfigure=0
 784     fi
 785
 786
 787     if [ ${do_reconfigure} -ne 0 ]
 788     then
 789     # because git is hilarious, it might have put the module index
 790     # in a couple places.
 791         index1="${CFG_SRC_DIR}.git/modules/src/llvm/index"
 792         index2="${CFG_SRC_DIR}src/llvm/.git/index"
 793         for index in ${index1} ${index2}
 794         do
 795             config_status="${CFG_BUILD_DIR}llvm/$t/config.status"
 796             if test -e ${index} -a \
 797                     -e ${config_status} -a \
 798                     ${config_status} -nt ${index}
 799             then
 800                 msg "not reconfiguring LLVM, config.status is fresh"
 801                 do_reconfigure=0
 802             fi
 803         done
 804     fi
 805
 806     if [ ${do_reconfigure} -ne 0 ]
 807     then
 808         msg "configuring LLVM for $t"
 809
 810         LLVM_TARGETS="--enable-targets=x86,x86_64,arm,mips"
 811         LLVM_BUILD="--build=$t"
 812         LLVM_HOST="--host=$t"
 813         LLVM_TARGET="--target=$t"
 814
 815         # Disable unused LLVM features
 816         LLVM_OPTS="$LLVM_DBG_OPTS --disable-docs \
 817                    --enable-bindings=none --disable-threads \
 818                    --disable-pthreads"
 819
 820         if [ "$CFG_C_COMPILER" = "clang" ]
 821         then
 822             LLVM_CXX_32="clang++ -m32"
 823             LLVM_CC_32="clang -m32"
 824
 825             LLVM_CXX_64="clang++"
 826             LLVM_CC_64="clang"
 827         else
 828             LLVM_CXX_32="g++ -m32"
 829             LLVM_CC_32="gcc -m32"
 830
 831             LLVM_CXX_64="g++"
 832             LLVM_CC_64="gcc"
 833         fi
 834
 835         LLVM_CFLAGS_32="-m32"
 836         LLVM_CXXFLAGS_32="-m32"
 837         LLVM_LDFLAGS_32="-m32"
 838
 839         LLVM_CFLAGS_64=""
 840         LLVM_CXXFLAGS_64=""
 841         LLVM_LDFLAGS_64=""
 842
 843         if echo $t | grep -q x86_64
 844         then
 845             LLVM_CXX=$LLVM_CXX_64
 846             LLVM_CC=$LLVM_CC_64
 847             LLVM_CFLAGS=$LLVM_CFLAGS_64
 848             LLVM_CXXFLAGS=$LLVM_CXXFLAGS_64
 849             LLVM_LDFLAGS=$LLVM_LDFLAGS_64
 850         else
 851             LLVM_CXX=$LLVM_CXX_32
 852             LLVM_CC=$LLVM_CC_32
 853             LLVM_CFLAGS=$LLVM_CFLAGS_32
 854             LLVM_CXXFLAGS=$LLVM_CXXFLAGS_32
 855             LLVM_LDFLAGS=$LLVM_LDFLAGS_32
 856         fi
 857
 858         CXX=$LLVM_CXX
 859         CC=$LLVM_CC
 860         CFLAGS=$LLVM_CFLAGS
 861         CXXFLAGS=$LLVM_CXXFLAGS
 862         LDFLAGS=$LLVM_LDFLAGS
 863
 864         LLVM_FLAGS="$LLVM_TARGETS $LLVM_OPTS $LLVM_BUILD \
 865                         $LLVM_HOST $LLVM_TARGET"
 866
 867         msg "configuring LLVM with:"
 868         msg "$LLVM_FLAGS"
 869
 870         export CXX
 871         export CC
 872         export CFLAGS
 873         export CXXFLAGS
 874         export LDFLAGS
 875
 876         cd $LLVM_BUILD_DIR
 877         case $CFG_SRC_DIR in
 878             /* | [a-z]:* | [A-Z]:*)
 879                 ${CFG_LLVM_SRC_DIR}configure $LLVM_FLAGS
 880                 ;;
 881             *)
 882                 ${CFG_BUILD_DIR}${CFG_LLVM_SRC_DIR}configure \
 883                     $LLVM_FLAGS
 884                 ;;
 885         esac
 886         need_ok "LLVM configure failed"
 887         cd $CFG_BUILD_DIR
 888     fi
 889
 890     # Construct variables for LLVM build and install directories for
 891     # each target. These will be named
 892     # CFG_LLVM_BUILD_DIR_${target_triple} but all the hyphens in
 893     # target_triple will be converted to underscore, because bash
 894     # variables can't contain hyphens. The makefile will then have to
 895     # convert back.
 896     CFG_LLVM_BUILD_DIR=$(echo CFG_LLVM_BUILD_DIR_${t} | tr - _)
 897     CFG_LLVM_INST_DIR=$(echo CFG_LLVM_INST_DIR_${t} | tr - _)
 898     eval ${CFG_LLVM_BUILD_DIR}="'$LLVM_BUILD_DIR'"
 899     eval ${CFG_LLVM_INST_DIR}="'$LLVM_INST_DIR'"
 900 done
 901
 902
 903 step_msg "writing configuration"
 904
 905 putvar CFG_SRC_DIR
 906 putvar CFG_BUILD_DIR
 907 putvar CFG_OSTYPE
 908 putvar CFG_CPUTYPE
 909 putvar CFG_CONFIGURE_ARGS
 910 putvar CFG_PREFIX
 911 putvar CFG_BUILD_TRIPLE
 912 putvar CFG_HOST_TRIPLES
 913 putvar CFG_TARGET_TRIPLES
 914 putvar CFG_C_COMPILER
 915 putvar CFG_LIBDIR
 916 putvar CFG_DISABLE_MANAGE_SUBMODULES
 917 putvar CFG_ANDROID_CROSS_PATH
 918 putvar CFG_MINGW32_CROSS_PATH
 919
 920 if [ ! -z "$CFG_ENABLE_PAX_FLAGS" ]
 921 then
 922     putvar CFG_ENABLE_PAX_FLAGS
 923     putvar CFG_PAXCTL
 924 fi
 925
 926 if [ ! -z $BAD_PANDOC ]
 927 then
 928     CFG_PANDOC=
 929     putvar CFG_PANDOC
 930 fi
 931
 932 if head -n 1 ${CFG_SRC_DIR}src/snapshots.txt | grep -q '^T'
 933 then
 934     CFG_IN_TRANSITION=1
 935     putvar CFG_IN_TRANSITION
 936 fi
 937
 938 # Valgrind is only reliable on Linux. On Windows it doesn't work at all, and
 939 # on the Mac the dynamic linker causes Valgrind to emit a huge stream of
 940 # errors.
 941 if [ $CFG_OSTYPE != unknown-linux-gnu ] && [ $CFG_OSTYPE != apple-darwin ]
 942 then
 943     CFG_BAD_VALGRIND=1
 944     putvar CFG_BAD_VALGRIND
 945 fi
 946
 947 putvar CFG_LLVM_ROOT
 948 putvar CFG_LLVM_SRC_DIR
 949
 950 for t in $CFG_HOST_TRIPLES
 951 do
 952     CFG_LLVM_BUILD_DIR=$(echo CFG_LLVM_BUILD_DIR_${t} | tr - _)
 953     CFG_LLVM_INST_DIR=$(echo CFG_LLVM_INST_DIR_${t} | tr - _)
 954     putvar $CFG_LLVM_BUILD_DIR
 955     putvar $CFG_LLVM_INST_DIR
 956 done
 957
 958 # Munge any paths that appear in config.mk back to posix-y
 959 perl -i.bak -p -e 's@ ([a-zA-Z]):[/\\]@ /\1/@go;' \
 960                -e 's@\\@/@go;' config.tmp
 961 rm -f config.tmp.bak
 962
 963 msg
 964 copy_if_changed ${CFG_SRC_DIR}Makefile.in ./Makefile
 965 move_if_changed config.tmp config.mk
 966 rm -f config.tmp
 967 touch config.stamp
 968
 969 step_msg "complete"