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 need_cmd file
 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 case $CFG_CPUTYPE in
 312
 313     i386 | i486 | i686 | i786 | x86)
 314         CFG_CPUTYPE=i686
 315         ;;
 316
 317     xscale | arm)
 318         CFG_CPUTYPE=arm
 319         ;;
 320
 321     x86_64 | x86-64 | x64 | amd64)
 322         CFG_CPUTYPE=x86_64
 323         ;;
 324
 325     *)
 326         err "unknown CPU type: $CFG_CPUTYPE"
 327 esac
 328
 329 # Detect 64 bit linux systems with 32 bit userland and force 32 bit compilation
 330 if [ $CFG_OSTYPE = unknown-linux-gnu -a $CFG_CPUTYPE = x86_64 ]
 331 then
 332     file -L "$SHELL" | grep -q "x86[_-]64"
 333     if [ $? != 0 ]; then
 334         CFG_CPUTYPE=i686
 335     fi
 336 fi
 337
 338
 339 DEFAULT_BUILD_TRIPLE="${CFG_CPUTYPE}-${CFG_OSTYPE}"
 340
 341 CFG_SRC_DIR="$(cd $(dirname $0) && pwd)/"
 342 CFG_BUILD_DIR="$(pwd)/"
 343 CFG_SELF=${CFG_SRC_DIR}$(basename $0)
 344 CFG_CONFIGURE_ARGS="$@"
 345
 346 OPTIONS=""
 347 HELP=0
 348 if [ "$1" = "--help" ]
 349 then
 350     HELP=1
 351     shift
 352     echo ""
 353     echo "Usage: $CFG_SELF [options]"
 354     echo ""
 355     echo "Options:"
 356     echo ""
 357 else
 358     msg "recreating config.tmp"
 359     echo '' >config.tmp
 360
 361     step_msg "processing $CFG_SELF args"
 362 fi
 363
 364 BOOL_OPTIONS=""
 365 VAL_OPTIONS=""
 366
 367 opt sharedstd 1 "build libstd as a shared library"
 368 opt valgrind 0 "run tests with valgrind (memcheck by default)"
 369 opt helgrind 0 "run tests with helgrind instead of memcheck"
 370 opt docs     1 "build documentation"
 371 opt optimize 1 "build optimized rust code"
 372 opt optimize-cxx 1 "build optimized C++ code"
 373 opt optimize-llvm 1 "build optimized LLVM"
 374 opt debug 0 "build with extra debug fun"
 375 opt fast-make 0 "use .gitmodules as timestamp for submodule deps"
 376 opt manage-submodules 1 "let the build manage the git submodules"
 377 opt mingw-cross 0 "cross-compile for win32 using mingw"
 378 opt clang 0 "prefer clang to gcc for building the runtime"
 379 opt ccache 0 "invoke gcc/clang via ccache to reuse object files between builds"
 380 opt local-rust 0 "use an installed rustc rather than downloading a snapshot"
 381 opt pax-flags 0 "apply PaX flags to rustc binaries (required for GRSecurity/PaX-patched kernels)"
 382 valopt prefix "/usr/local" "set installation prefix"
 383 valopt local-rust-root "/usr/local" "set prefix for local rust binary"
 384 valopt llvm-root "" "set LLVM root"
 385 valopt build-triple "${DEFAULT_BUILD_TRIPLE}" "LLVM build triple"
 386 valopt host-triples "${CFG_BUILD_TRIPLE}" "LLVM host triples"
 387 valopt target-triples "${CFG_HOST_TRIPLES}" "LLVM target triples"
 388 valopt android-cross-path "/opt/ndk_standalone" "Android NDK standalone path"
 389 valopt mingw32-cross-path "" "MinGW32 cross compiler path"
 390
 391 # Validate Options
 392 step_msg "validating $CFG_SELF args"
 393 validate_opt
 394
 395 if [ $HELP -eq 1 ]
 396 then
 397     echo ""
 398     exit 0
 399 fi
 400
 401
 402 step_msg "looking for build programs"
 403
 404 probe_need CFG_PERL        perl
 405 probe_need CFG_CURL        curl
 406 probe_need CFG_PYTHON      python2.7 python2.6 python2 python
 407
 408 python_version=$($CFG_PYTHON -V 2>&1)
 409 if [ $(echo $python_version | grep -c '^Python 2\.[4567]') -ne 1 ]; then
 410     err "Found $python_version, but LLVM requires Python 2.4-2.7"
 411 fi
 412
 413 # If we have no git directory then we are probably a tarball distribution
 414 # and shouldn't attempt to load submodules
 415 if [ ! -e ${CFG_SRC_DIR}.git ]
 416 then
 417     probe CFG_GIT          git
 418     msg "git: no git directory. disabling submodules"
 419     CFG_DISABLE_MANAGE_SUBMODULES=1
 420 else
 421     probe_need CFG_GIT     git
 422 fi
 423
 424 probe CFG_CLANG            clang++
 425 probe CFG_CCACHE           ccache
 426 probe CFG_GCC              gcc
 427 probe CFG_LD               ld
 428 probe CFG_VALGRIND         valgrind
 429 probe CFG_PERF             perf
 430 probe CFG_ISCC             iscc
 431 probe CFG_LLNEXTGEN        LLnextgen
 432 probe CFG_PANDOC           pandoc
 433 probe CFG_PDFLATEX         pdflatex
 434 probe CFG_XETEX            xetex
 435 probe CFG_LUATEX           luatex
 436 probe CFG_NODE             nodejs node
 437 probe CFG_GDB              gdb
 438 if [ "$CFG_OSTYPE" = "unknown-linux-gnu" ]
 439 then
 440     probe CFG_PAXCTL           paxctl /sbin/paxctl
 441     probe CFG_ZCAT             zcat
 442 fi
 443
 444 step_msg "looking for target specific programs"
 445
 446 probe CFG_ADB        adb
 447
 448 if [ ! -z "$CFG_PANDOC" ]
 449 then
 450     PV_MAJOR_MINOR=$(pandoc --version | grep '^pandoc ' |
 451         # extract the first 2 version fields, ignore everything else
 452         sed 's/pandoc \([0-9]*\)\.\([0-9]*\).*/\1 \2/')
 453
 454     # these patterns are shell globs, *not* regexps
 455     PV_MAJOR=${PV_MAJOR_MINOR% *}
 456     PV_MINOR=${PV_MAJOR_MINOR#* }
 457     if [ "$PV_MAJOR" -lt "1" ] || [ "$PV_MINOR" -lt "8" ]
 458     then
 459                 step_msg "pandoc $PV_MAJOR.$PV_MINOR is too old. disabling"
 460                 BAD_PANDOC=1
 461     fi
 462 fi
 463
 464 if [ "$CFG_OSTYPE" = "unknown-linux-gnu" ]
 465 then
 466     if [ ! -z "$CFG_ENABLE_PAX_FLAGS" -a -z "$CFG_PAXCTL" ]
 467     then
 468         err "enabled PaX markings but no paxctl binary found"
 469     fi
 470
 471     if [ -z "$CFG_DISABLE_PAX_FLAGS" ]
 472     then
 473         # GRSecurity/PaX detection. This can be very flaky.
 474         GRSEC_DETECTED=
 475
 476         # /dev/grsec only exists if CONFIG_GRKERNSEC_NO_RBAC is not set.
 477         # /proc/sys/kernel/grsecurity is not available if ÇONFIG_GRKERNSEC_SYSCTL is not set.
 478         if [ -e /dev/grsec -o -d /proc/sys/kernel/grsecurity ]
 479         then
 480             GRSEC_DETECTED=1
 481         # /proc/config.gz is normally only available to root, and only if CONFIG_IKCONFIG_PROC has been set.
 482         elif [ -r /proc/config.gz -a ! -z "$CFG_ZCAT" ]
 483         then
 484             if "$CFG_ZCAT" /proc/config.gz | grep --quiet "CONFIG_GRKERNSEC=y"
 485             then
 486                 GRSEC_DETECTED=1
 487             fi
 488         # Flaky.
 489         elif grep --quiet grsec /proc/version
 490         then
 491             GRSEC_DETECTED=1
 492         fi
 493
 494         if [ ! -z "$GRSEC_DETECTED" ]
 495         then
 496             step_msg "GRSecurity: yes"
 497             if [ ! -z "$CFG_PAXCTL" ]
 498             then
 499                 CFG_ENABLE_PAX_FLAGS=1
 500             else
 501                 warn "GRSecurity kernel detected but no paxctl binary found: not setting CFG_ENABLE_PAX_FLAGS"
 502             fi
 503         else
 504             step_msg "GRSecurity: no"
 505         fi
 506     fi
 507 fi
 508
 509 if [ ! -z "$CFG_ENABLE_LOCAL_RUST" ]
 510 then
 511     if [ ! -f ${CFG_LOCAL_RUST_ROOT}/bin/rustc ]
 512     then
 513         err "no local rust to use"
 514     else
 515         LRV=`${CFG_LOCAL_RUST_ROOT}/bin/rustc --version`
 516         step_msg "using rustc at: ${CFG_LOCAL_RUST_ROOT} with version: " $LRV
 517     fi
 518 fi
 519
 520 # Force freebsd to build with clang; gcc doesn't like us there
 521 if [ $CFG_OSTYPE = unknown-freebsd ]
 522 then
 523     step_msg "on FreeBSD, forcing use of clang"
 524     CFG_ENABLE_CLANG=1
 525     putvar CFG_ENABLE_CLANG
 526 fi
 527
 528
 529 if [ -z "$CFG_ENABLE_CLANG" -a -z "$CFG_GCC" ]
 530 then
 531     err "either clang or gcc is required"
 532 fi
 533
 534 if [ ! -z "$CFG_LLVM_ROOT" -a -e "$CFG_LLVM_ROOT/bin/llvm-config" ]
 535 then
 536     step_msg "using custom LLVM at $CFG_LLVM_ROOT"
 537
 538     LLVM_CONFIG="$CFG_LLVM_ROOT/bin/llvm-config"
 539     LLVM_VERSION=$($LLVM_CONFIG --version)
 540
 541     case $LLVM_VERSION in
 542         (3.3|3.3svn|3.2|3.2svn)
 543             msg "found ok version of LLVM: $LLVM_VERSION"
 544             ;;
 545         (*)
 546             err "bad LLVM version: $LLVM_VERSION, need >=3.0svn"
 547             ;;
 548     esac
 549 fi
 550
 551 if [ ! -z "$CFG_ENABLE_CLANG" ]
 552 then
 553     if [ -z "$CFG_CLANG" ]
 554     then
 555         err "clang requested but not found"
 556     fi
 557     CFG_CLANG_VERSION=$("$CFG_CLANG" \
 558                       --version \
 559                       | grep version \
 560                       | sed 's/.*\(version .*\)/\1/; s/.*based on \(LLVM .*\))/\1/' \
 561                       | cut -d ' ' -f 2)
 562
 563     case $CFG_CLANG_VERSION in
 564         (3.0svn | 3.0 | 3.1* | 3.2* | 3.3* | 3.4* )
 565         step_msg "found ok version of CLANG: $CFG_CLANG_VERSION"
 566         CFG_C_COMPILER="clang"
 567         ;;
 568         (*)
 569         err "bad CLANG version: $CFG_CLANG_VERSION, need >=3.0svn"
 570         ;;
 571     esac
 572 else
 573     CFG_C_COMPILER="gcc"
 574 fi
 575
 576 if [ ! -z "$CFG_ENABLE_CCACHE" ]
 577 then
 578     if [ -z "$CFG_CCACHE" ]
 579     then
 580         err "ccache requested but not found"
 581     fi
 582
 583     CFG_C_COMPILER="ccache $CFG_C_COMPILER"
 584 fi
 585
 586 # a little post-processing of various config values
 587
 588 CFG_PREFIX=${CFG_PREFIX%/}
 589 CFG_HOST_TRIPLES="$(echo $CFG_HOST_TRIPLES | tr ',' ' ')"
 590 CFG_TARGET_TRIPLES="$(echo $CFG_TARGET_TRIPLES | tr ',' ' ')"
 591 CFG_SUPPORTED_TARGET_TRIPLES="$(grep ^CC_*=* $CFG_SRC_DIR/mk/platform.mk | sed -e 's/^CC_//' -e 's/\([^=]*\).*/\1/' | xargs)"
 592
 593 # copy host-triples to target-triples so that hosts are a subset of targets
 594 V_TEMP=""
 595 for i in $CFG_HOST_TRIPLES $CFG_TARGET_TRIPLES;
 596 do
 597    echo "$V_TEMP" | grep -qF $i || V_TEMP="$V_TEMP${V_TEMP:+ }$i"
 598 done
 599 CFG_TARGET_TRIPLES=$V_TEMP
 600
 601 # check target-specific tool-chains
 602 for i in $CFG_TARGET_TRIPLES
 603 do
 604     L_CHECK=false
 605     for j in $CFG_SUPPORTED_TARGET_TRIPLES
 606     do
 607         if [ $i = $j ]
 608         then
 609             L_CHECK=true
 610         fi
 611     done
 612
 613     if [ $L_CHECK = false ]
 614     then
 615         err "unsupported target triples \"$i\" found"
 616     fi
 617
 618     case $i in
 619         arm-linux-androideabi)
 620
 621             if [ ! -f $CFG_ANDROID_CROSS_PATH/bin/arm-linux-androideabi-gcc ]
 622             then
 623                 err "NDK $CFG_ANDROID_CROSS_PATH/bin/arm-linux-androideabi-gcc not found"
 624             fi
 625             if [ ! -f $CFG_ANDROID_CROSS_PATH/bin/arm-linux-androideabi-g++ ]
 626             then
 627                 err "NDK $CFG_ANDROID_CROSS_PATH/bin/arm-linux-androideabi-g++ not found"
 628             fi
 629             if [ ! -f $CFG_ANDROID_CROSS_PATH/bin/arm-linux-androideabi-ar ]
 630             then
 631                 err "NDK $CFG_ANDROID_CROSS_PATH/bin/arm-linux-androideabi-ar not found"
 632             fi
 633             ;;
 634
 635         *)
 636             ;;
 637     esac
 638 done
 639
 640 if [ -z "$CFG_ENABLE_CLANG" -a -z "$CFG_GCC" ]
 641 then
 642     err "either clang or gcc is required"
 643 fi
 644
 645 if [ ! -z "$CFG_PERF" ]
 646 then
 647     HAVE_PERF_LOGFD=`$CFG_PERF stat --log-fd 2>&1 | grep 'unknown option'`
 648     if [ -z "$HAVE_PERF_LOGFD" ];
 649     then
 650         CFG_PERF_WITH_LOGFD=1
 651         putvar CFG_PERF_WITH_LOGFD
 652     fi
 653 fi
 654
 655 step_msg "making directories"
 656
 657 for i in \
 658     doc doc/std doc/extra \
 659     dl tmp
 660 do
 661     make_dir $i
 662 done
 663
 664 make_dir llvm
 665 for t in $CFG_HOST_TRIPLES
 666 do
 667     make_dir llvm/$t
 668 done
 669
 670 make_dir rustllvm
 671 for t in $CFG_HOST_TRIPLES
 672 do
 673     make_dir rustllvm/$t
 674 done
 675
 676 make_dir rt
 677 for t in $CFG_TARGET_TRIPLES
 678 do
 679   make_dir rt/$t
 680   for s in 0 1 2 3
 681   do
 682     make_dir rt/$t/stage$s
 683     for i in                                          \
 684       isaac linenoise sync test \
 685       arch/i386 arch/x86_64 arch/arm arch/mips  \
 686       libuv libuv/src/ares libuv/src/eio libuv/src/ev
 687     do
 688       make_dir rt/$t/stage$s/$i
 689     done
 690   done
 691 done
 692
 693 # On windows we just store the libraries in the bin directory because
 694 # there's no rpath
 695 # FIXME: Thise needs to parameterized over target triples. Do it in platform.mk
 696 CFG_LIBDIR=lib
 697 if [ "$CFG_OSTYPE" = "pc-mingw32" ]
 698 then
 699     CFG_LIBDIR=bin
 700 fi
 701
 702 for h in $CFG_HOST_TRIPLES
 703 do
 704     for t in $CFG_TARGET_TRIPLES
 705     do
 706         for i in 0 1 2 3
 707         do
 708             # host bin dir
 709             make_dir $h/stage$i/bin
 710
 711             # host lib dir
 712             make_dir $h/stage$i/$CFG_LIBDIR
 713
 714             # host test dir
 715             make_dir $h/stage$i/test
 716
 717             # target bin dir
 718             make_dir $h/stage$i/$CFG_LIBDIR/rustc/$t/bin
 719
 720             # target lib dir
 721             make_dir $h/stage$i/$CFG_LIBDIR/rustc/$t/$CFG_LIBDIR
 722         done
 723     done
 724
 725     make_dir $h/test/run-pass
 726     make_dir $h/test/run-pass-fulldeps
 727     make_dir $h/test/run-fail
 728     make_dir $h/test/compile-fail
 729     make_dir $h/test/bench
 730     make_dir $h/test/perf
 731     make_dir $h/test/pretty
 732     make_dir $h/test/debug-info
 733     make_dir $h/test/doc-tutorial
 734     make_dir $h/test/doc-tutorial-ffi
 735     make_dir $h/test/doc-tutorial-macros
 736     make_dir $h/test/doc-tutorial-borrowed-ptr
 737     make_dir $h/test/doc-tutorial-tasks
 738     make_dir $h/test/doc-rust
 739 done
 740
 741 # Configure submodules
 742 step_msg "configuring submodules"
 743
 744 # Have to be in the top of src directory for this
 745 if [ -z $CFG_DISABLE_MANAGE_SUBMODULES ]
 746 then
 747     cd ${CFG_SRC_DIR}
 748
 749     msg "git: submodule sync"
 750     "${CFG_GIT}" submodule --quiet sync
 751
 752     msg "git: submodule update"
 753     "${CFG_GIT}" submodule --quiet update --init
 754     need_ok "git failed"
 755
 756     msg "git: submodule foreach sync"
 757     "${CFG_GIT}" submodule --quiet foreach --recursive 'if test -e .gitmodules; then git submodule sync; fi'
 758     need_ok "git failed"
 759
 760     msg "git: submodule foreach update"
 761     "${CFG_GIT}" submodule --quiet update --init --recursive
 762     need_ok "git failed"
 763
 764     # NB: this is just for the sake of getting the submodule SHA1 values
 765     # and status written into the build log.
 766     msg "git: submodule status"
 767     "${CFG_GIT}" submodule status --recursive
 768
 769     msg "git: submodule clobber"
 770     "${CFG_GIT}" submodule --quiet foreach --recursive git clean -dxf
 771     need_ok "git failed"
 772     "${CFG_GIT}" submodule --quiet foreach --recursive git checkout .
 773     need_ok "git failed"
 774
 775     cd ${CFG_BUILD_DIR}
 776 fi
 777
 778 # Configure llvm, only if necessary
 779 step_msg "looking at LLVM"
 780 CFG_LLVM_SRC_DIR=${CFG_SRC_DIR}src/llvm/
 781 for t in $CFG_HOST_TRIPLES
 782 do
 783     do_reconfigure=1
 784
 785     if [ -z $CFG_LLVM_ROOT ]
 786     then
 787         LLVM_BUILD_DIR=${CFG_BUILD_DIR}llvm/$t
 788         if [ ! -z "$CFG_DISABLE_OPTIMIZE_LLVM" ]
 789         then
 790             LLVM_DBG_OPTS="--enable-debug-symbols --disable-optimized"
 791             # Just use LLVM straight from its build directory to
 792             # avoid 'make install' time
 793             LLVM_INST_DIR=$LLVM_BUILD_DIR/Debug+Asserts
 794         else
 795             LLVM_DBG_OPTS="--enable-optimized"
 796             LLVM_INST_DIR=$LLVM_BUILD_DIR/Release+Asserts
 797         fi
 798     else
 799         msg "not reconfiguring LLVM, external LLVM root"
 800         # The user is using their own LLVM
 801         LLVM_BUILD_DIR=
 802         LLVM_INST_DIR=$CFG_LLVM_ROOT
 803         do_reconfigure=0
 804     fi
 805
 806
 807     if [ ${do_reconfigure} -ne 0 ]
 808     then
 809     # because git is hilarious, it might have put the module index
 810     # in a couple places.
 811         index1="${CFG_SRC_DIR}.git/modules/src/llvm/index"
 812         index2="${CFG_SRC_DIR}src/llvm/.git/index"
 813         for index in ${index1} ${index2}
 814         do
 815             config_status="${CFG_BUILD_DIR}llvm/$t/config.status"
 816             if test -e ${index} -a \
 817                     -e ${config_status} -a \
 818                     ${config_status} -nt ${index}
 819             then
 820                 msg "not reconfiguring LLVM, config.status is fresh"
 821                 do_reconfigure=0
 822             fi
 823         done
 824     fi
 825
 826     if [ ${do_reconfigure} -ne 0 ]
 827     then
 828         msg "configuring LLVM for $t"
 829
 830         LLVM_TARGETS="--enable-targets=x86,x86_64,arm,mips"
 831         LLVM_BUILD="--build=$t"
 832         LLVM_HOST="--host=$t"
 833         LLVM_TARGET="--target=$t"
 834
 835         # Disable unused LLVM features
 836         LLVM_OPTS="$LLVM_DBG_OPTS --disable-docs \
 837                    --enable-bindings=none --disable-threads \
 838                    --disable-pthreads"
 839
 840         case "$CFG_C_COMPILER" in
 841             ("ccache clang")
 842             LLVM_CXX_32="ccache clang++ -m32 -Qunused-arguments"
 843             LLVM_CC_32="ccache clang -m32 -Qunused-arguments"
 844
 845             LLVM_CXX_64="ccache clang++ -Qunused-arguments"
 846             LLVM_CC_64="ccache clang -Qunused-arguments"
 847             ;;
 848             ("clang")
 849             LLVM_CXX_32="clang++ -m32"
 850             LLVM_CC_32="clang -m32"
 851
 852             LLVM_CXX_64="clang++"
 853             LLVM_CC_64="clang"
 854             ;;
 855             ("ccache gcc")
 856             LLVM_CXX_32="ccache g++ -m32"
 857             LLVM_CC_32="ccache gcc -m32"
 858
 859             LLVM_CXX_64="ccache g++"
 860             LLVM_CC_64="ccache gcc"
 861             ;;
 862             ("gcc")
 863             LLVM_CXX_32="g++ -m32"
 864             LLVM_CC_32="gcc -m32"
 865
 866             LLVM_CXX_64="g++"
 867             LLVM_CC_64="gcc"
 868         esac
 869
 870         LLVM_CFLAGS_32="-m32"
 871         LLVM_CXXFLAGS_32="-m32"
 872         LLVM_LDFLAGS_32="-m32"
 873
 874         LLVM_CFLAGS_64=""
 875         LLVM_CXXFLAGS_64=""
 876         LLVM_LDFLAGS_64=""
 877
 878         if echo $t | grep -q x86_64
 879         then
 880             LLVM_CXX=$LLVM_CXX_64
 881             LLVM_CC=$LLVM_CC_64
 882             LLVM_CFLAGS=$LLVM_CFLAGS_64
 883             LLVM_CXXFLAGS=$LLVM_CXXFLAGS_64
 884             LLVM_LDFLAGS=$LLVM_LDFLAGS_64
 885         else
 886             LLVM_CXX=$LLVM_CXX_32
 887             LLVM_CC=$LLVM_CC_32
 888             LLVM_CFLAGS=$LLVM_CFLAGS_32
 889             LLVM_CXXFLAGS=$LLVM_CXXFLAGS_32
 890             LLVM_LDFLAGS=$LLVM_LDFLAGS_32
 891         fi
 892
 893         CXX=$LLVM_CXX
 894         CC=$LLVM_CC
 895         CFLAGS=$LLVM_CFLAGS
 896         CXXFLAGS=$LLVM_CXXFLAGS
 897         LDFLAGS=$LLVM_LDFLAGS
 898
 899         LLVM_FLAGS="$LLVM_TARGETS $LLVM_OPTS $LLVM_BUILD \
 900                         $LLVM_HOST $LLVM_TARGET --with-python=$CFG_PYTHON"
 901
 902         msg "configuring LLVM with:"
 903         msg "$LLVM_FLAGS"
 904
 905         export CXX
 906         export CC
 907         export CFLAGS
 908         export CXXFLAGS
 909         export LDFLAGS
 910
 911         cd $LLVM_BUILD_DIR
 912         case $CFG_SRC_DIR in
 913             /* | [a-z]:* | [A-Z]:*)
 914                 ${CFG_LLVM_SRC_DIR}configure $LLVM_FLAGS
 915                 ;;
 916             *)
 917                 ${CFG_BUILD_DIR}${CFG_LLVM_SRC_DIR}configure \
 918                     $LLVM_FLAGS
 919                 ;;
 920         esac
 921         need_ok "LLVM configure failed"
 922
 923         # Hack the tools Makefile to turn off the clang build
 924         sed -i 's/clang//g' tools/Makefile
 925
 926         cd $CFG_BUILD_DIR
 927     fi
 928
 929     # Construct variables for LLVM build and install directories for
 930     # each target. These will be named
 931     # CFG_LLVM_BUILD_DIR_${target_triple} but all the hyphens in
 932     # target_triple will be converted to underscore, because bash
 933     # variables can't contain hyphens. The makefile will then have to
 934     # convert back.
 935     CFG_LLVM_BUILD_DIR=$(echo CFG_LLVM_BUILD_DIR_${t} | tr - _)
 936     CFG_LLVM_INST_DIR=$(echo CFG_LLVM_INST_DIR_${t} | tr - _)
 937     eval ${CFG_LLVM_BUILD_DIR}="'$LLVM_BUILD_DIR'"
 938     eval ${CFG_LLVM_INST_DIR}="'$LLVM_INST_DIR'"
 939 done
 940
 941
 942 step_msg "writing configuration"
 943
 944 putvar CFG_SRC_DIR
 945 putvar CFG_BUILD_DIR
 946 putvar CFG_OSTYPE
 947 putvar CFG_CPUTYPE
 948 putvar CFG_CONFIGURE_ARGS
 949 putvar CFG_PREFIX
 950 putvar CFG_BUILD_TRIPLE
 951 putvar CFG_HOST_TRIPLES
 952 putvar CFG_TARGET_TRIPLES
 953 putvar CFG_C_COMPILER
 954 putvar CFG_LIBDIR
 955 putvar CFG_DISABLE_MANAGE_SUBMODULES
 956 putvar CFG_ANDROID_CROSS_PATH
 957 putvar CFG_MINGW32_CROSS_PATH
 958
 959 if [ ! -z "$CFG_ENABLE_PAX_FLAGS" ]
 960 then
 961     putvar CFG_ENABLE_PAX_FLAGS
 962     putvar CFG_PAXCTL
 963 fi
 964
 965 # Avoid spurious warnings from clang by feeding it original source on
 966 # ccache-miss rather than preprocessed input.
 967 if [ ! -z "$CFG_ENABLE_CCACHE" ] && [ ! -z "$CFG_ENABLE_CLANG" ]
 968 then
 969     CFG_CCACHE_CPP2=1
 970     putvar CFG_CCACHE_CPP2
 971 fi
 972
 973 if [ ! -z "$CFG_ENABLE_CCACHE" ]
 974 then
 975     CFG_CCACHE_BASEDIR=${CFG_SRC_DIR}
 976     putvar CFG_CCACHE_BASEDIR
 977 fi
 978
 979
 980 if [ ! -z $BAD_PANDOC ]
 981 then
 982     CFG_PANDOC=
 983     putvar CFG_PANDOC
 984 fi
 985
 986 if head -n 1 ${CFG_SRC_DIR}src/snapshots.txt | grep -q '^T'
 987 then
 988     CFG_IN_TRANSITION=1
 989     putvar CFG_IN_TRANSITION
 990 fi
 991
 992 # Valgrind is only reliable on Linux. On Windows it doesn't work at all, and
 993 # on the Mac the dynamic linker causes Valgrind to emit a huge stream of
 994 # errors.
 995 if [ $CFG_OSTYPE != unknown-linux-gnu ] && [ $CFG_OSTYPE != apple-darwin ]
 996 then
 997     CFG_BAD_VALGRIND=1
 998     putvar CFG_BAD_VALGRIND
 999 fi
1000
1001 putvar CFG_LLVM_ROOT
1002 putvar CFG_LLVM_SRC_DIR
1003
1004 for t in $CFG_HOST_TRIPLES
1005 do
1006     CFG_LLVM_BUILD_DIR=$(echo CFG_LLVM_BUILD_DIR_${t} | tr - _)
1007     CFG_LLVM_INST_DIR=$(echo CFG_LLVM_INST_DIR_${t} | tr - _)
1008     putvar $CFG_LLVM_BUILD_DIR
1009     putvar $CFG_LLVM_INST_DIR
1010 done
1011
1012 # Munge any paths that appear in config.mk back to posix-y
1013 perl -i.bak -p -e 's@ ([a-zA-Z]):[/\\]@ /\1/@go;' \
1014                -e 's@\\@/@go;' config.tmp
1015 rm -f config.tmp.bak
1016
1017 msg
1018 copy_if_changed ${CFG_SRC_DIR}Makefile.in ./Makefile
1019 move_if_changed config.tmp config.mk
1020 rm -f config.tmp
1021 touch config.stamp
1022
1023 step_msg "complete"