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       jemalloc
 688     do
 689       make_dir rt/$t/stage$s/$i
 690     done
 691   done
 692 done
 693
 694 # On windows we just store the libraries in the bin directory because
 695 # there's no rpath
 696 # FIXME: Thise needs to parameterized over target triples. Do it in platform.mk
 697 CFG_LIBDIR=lib
 698 if [ "$CFG_OSTYPE" = "pc-mingw32" ]
 699 then
 700     CFG_LIBDIR=bin
 701 fi
 702
 703 for h in $CFG_HOST_TRIPLES
 704 do
 705     for t in $CFG_TARGET_TRIPLES
 706     do
 707         for i in 0 1 2 3
 708         do
 709             # host bin dir
 710             make_dir $h/stage$i/bin
 711
 712             # host lib dir
 713             make_dir $h/stage$i/$CFG_LIBDIR
 714
 715             # host test dir
 716             make_dir $h/stage$i/test
 717
 718             # target bin dir
 719             make_dir $h/stage$i/$CFG_LIBDIR/rustc/$t/bin
 720
 721             # target lib dir
 722             make_dir $h/stage$i/$CFG_LIBDIR/rustc/$t/$CFG_LIBDIR
 723         done
 724     done
 725
 726     make_dir $h/test/run-pass
 727     make_dir $h/test/run-pass-fulldeps
 728     make_dir $h/test/run-fail
 729     make_dir $h/test/compile-fail
 730     make_dir $h/test/bench
 731     make_dir $h/test/perf
 732     make_dir $h/test/pretty
 733     make_dir $h/test/debug-info
 734     make_dir $h/test/doc-tutorial
 735     make_dir $h/test/doc-tutorial-ffi
 736     make_dir $h/test/doc-tutorial-macros
 737     make_dir $h/test/doc-tutorial-borrowed-ptr
 738     make_dir $h/test/doc-tutorial-tasks
 739     make_dir $h/test/doc-rust
 740 done
 741
 742 # Configure submodules
 743 step_msg "configuring submodules"
 744
 745 # Have to be in the top of src directory for this
 746 if [ -z $CFG_DISABLE_MANAGE_SUBMODULES ]
 747 then
 748     cd ${CFG_SRC_DIR}
 749
 750     msg "git: submodule sync"
 751     "${CFG_GIT}" submodule --quiet sync
 752
 753     msg "git: submodule update"
 754     "${CFG_GIT}" submodule --quiet update --init
 755     need_ok "git failed"
 756
 757     msg "git: submodule foreach sync"
 758     "${CFG_GIT}" submodule --quiet foreach --recursive 'if test -e .gitmodules; then git submodule sync; fi'
 759     need_ok "git failed"
 760
 761     msg "git: submodule foreach update"
 762     "${CFG_GIT}" submodule --quiet update --init --recursive
 763     need_ok "git failed"
 764
 765     # NB: this is just for the sake of getting the submodule SHA1 values
 766     # and status written into the build log.
 767     msg "git: submodule status"
 768     "${CFG_GIT}" submodule status --recursive
 769
 770     msg "git: submodule clobber"
 771     "${CFG_GIT}" submodule --quiet foreach --recursive git clean -dxf
 772     need_ok "git failed"
 773     "${CFG_GIT}" submodule --quiet foreach --recursive git checkout .
 774     need_ok "git failed"
 775
 776     cd ${CFG_BUILD_DIR}
 777 fi
 778
 779 # Configure llvm, only if necessary
 780 step_msg "looking at LLVM"
 781 CFG_LLVM_SRC_DIR=${CFG_SRC_DIR}src/llvm/
 782 for t in $CFG_HOST_TRIPLES
 783 do
 784     do_reconfigure=1
 785
 786     if [ -z $CFG_LLVM_ROOT ]
 787     then
 788         LLVM_BUILD_DIR=${CFG_BUILD_DIR}llvm/$t
 789         if [ ! -z "$CFG_DISABLE_OPTIMIZE_LLVM" ]
 790         then
 791             LLVM_DBG_OPTS="--enable-debug-symbols --disable-optimized"
 792             # Just use LLVM straight from its build directory to
 793             # avoid 'make install' time
 794             LLVM_INST_DIR=$LLVM_BUILD_DIR/Debug+Asserts
 795         else
 796             LLVM_DBG_OPTS="--enable-optimized"
 797             LLVM_INST_DIR=$LLVM_BUILD_DIR/Release+Asserts
 798         fi
 799     else
 800         msg "not reconfiguring LLVM, external LLVM root"
 801         # The user is using their own LLVM
 802         LLVM_BUILD_DIR=
 803         LLVM_INST_DIR=$CFG_LLVM_ROOT
 804         do_reconfigure=0
 805     fi
 806
 807
 808     if [ ${do_reconfigure} -ne 0 ]
 809     then
 810     # because git is hilarious, it might have put the module index
 811     # in a couple places.
 812         index1="${CFG_SRC_DIR}.git/modules/src/llvm/index"
 813         index2="${CFG_SRC_DIR}src/llvm/.git/index"
 814         for index in ${index1} ${index2}
 815         do
 816             config_status="${CFG_BUILD_DIR}llvm/$t/config.status"
 817             if test -e ${index} -a \
 818                     -e ${config_status} -a \
 819                     ${config_status} -nt ${index}
 820             then
 821                 msg "not reconfiguring LLVM, config.status is fresh"
 822                 do_reconfigure=0
 823             fi
 824         done
 825     fi
 826
 827     if [ ${do_reconfigure} -ne 0 ]
 828     then
 829         msg "configuring LLVM for $t"
 830
 831         LLVM_TARGETS="--enable-targets=x86,x86_64,arm,mips"
 832         LLVM_BUILD="--build=$t"
 833         LLVM_HOST="--host=$t"
 834         LLVM_TARGET="--target=$t"
 835
 836         # Disable unused LLVM features
 837         LLVM_OPTS="$LLVM_DBG_OPTS --disable-docs \
 838                    --enable-bindings=none --disable-threads \
 839                    --disable-pthreads"
 840
 841         case "$CFG_C_COMPILER" in
 842             ("ccache clang")
 843             LLVM_CXX_32="ccache clang++ -m32 -Qunused-arguments"
 844             LLVM_CC_32="ccache clang -m32 -Qunused-arguments"
 845
 846             LLVM_CXX_64="ccache clang++ -Qunused-arguments"
 847             LLVM_CC_64="ccache clang -Qunused-arguments"
 848             ;;
 849             ("clang")
 850             LLVM_CXX_32="clang++ -m32"
 851             LLVM_CC_32="clang -m32"
 852
 853             LLVM_CXX_64="clang++"
 854             LLVM_CC_64="clang"
 855             ;;
 856             ("ccache gcc")
 857             LLVM_CXX_32="ccache g++ -m32"
 858             LLVM_CC_32="ccache gcc -m32"
 859
 860             LLVM_CXX_64="ccache g++"
 861             LLVM_CC_64="ccache gcc"
 862             ;;
 863             ("gcc")
 864             LLVM_CXX_32="g++ -m32"
 865             LLVM_CC_32="gcc -m32"
 866
 867             LLVM_CXX_64="g++"
 868             LLVM_CC_64="gcc"
 869         esac
 870
 871         LLVM_CFLAGS_32="-m32"
 872         LLVM_CXXFLAGS_32="-m32"
 873         LLVM_LDFLAGS_32="-m32"
 874
 875         LLVM_CFLAGS_64=""
 876         LLVM_CXXFLAGS_64=""
 877         LLVM_LDFLAGS_64=""
 878
 879         if echo $t | grep -q x86_64
 880         then
 881             LLVM_CXX=$LLVM_CXX_64
 882             LLVM_CC=$LLVM_CC_64
 883             LLVM_CFLAGS=$LLVM_CFLAGS_64
 884             LLVM_CXXFLAGS=$LLVM_CXXFLAGS_64
 885             LLVM_LDFLAGS=$LLVM_LDFLAGS_64
 886         else
 887             LLVM_CXX=$LLVM_CXX_32
 888             LLVM_CC=$LLVM_CC_32
 889             LLVM_CFLAGS=$LLVM_CFLAGS_32
 890             LLVM_CXXFLAGS=$LLVM_CXXFLAGS_32
 891             LLVM_LDFLAGS=$LLVM_LDFLAGS_32
 892         fi
 893
 894         CXX=$LLVM_CXX
 895         CC=$LLVM_CC
 896         CFLAGS=$LLVM_CFLAGS
 897         CXXFLAGS=$LLVM_CXXFLAGS
 898         LDFLAGS=$LLVM_LDFLAGS
 899
 900         LLVM_FLAGS="$LLVM_TARGETS $LLVM_OPTS $LLVM_BUILD \
 901                         $LLVM_HOST $LLVM_TARGET --with-python=$CFG_PYTHON"
 902
 903         msg "configuring LLVM with:"
 904         msg "$LLVM_FLAGS"
 905
 906         export CXX
 907         export CC
 908         export CFLAGS
 909         export CXXFLAGS
 910         export LDFLAGS
 911
 912         cd $LLVM_BUILD_DIR
 913         case $CFG_SRC_DIR in
 914             /* | [a-z]:* | [A-Z]:*)
 915                 ${CFG_LLVM_SRC_DIR}configure $LLVM_FLAGS
 916                 ;;
 917             *)
 918                 ${CFG_BUILD_DIR}${CFG_LLVM_SRC_DIR}configure \
 919                     $LLVM_FLAGS
 920                 ;;
 921         esac
 922         need_ok "LLVM configure failed"
 923
 924         # Hack the tools Makefile to turn off the clang build
 925         sed -i 's/clang//g' tools/Makefile
 926
 927         cd $CFG_BUILD_DIR
 928     fi
 929
 930     # Construct variables for LLVM build and install directories for
 931     # each target. These will be named
 932     # CFG_LLVM_BUILD_DIR_${target_triple} but all the hyphens in
 933     # target_triple will be converted to underscore, because bash
 934     # variables can't contain hyphens. The makefile will then have to
 935     # convert back.
 936     CFG_LLVM_BUILD_DIR=$(echo CFG_LLVM_BUILD_DIR_${t} | tr - _)
 937     CFG_LLVM_INST_DIR=$(echo CFG_LLVM_INST_DIR_${t} | tr - _)
 938     eval ${CFG_LLVM_BUILD_DIR}="'$LLVM_BUILD_DIR'"
 939     eval ${CFG_LLVM_INST_DIR}="'$LLVM_INST_DIR'"
 940 done
 941
 942
 943 step_msg "writing configuration"
 944
 945 putvar CFG_SRC_DIR
 946 putvar CFG_BUILD_DIR
 947 putvar CFG_OSTYPE
 948 putvar CFG_CPUTYPE
 949 putvar CFG_CONFIGURE_ARGS
 950 putvar CFG_PREFIX
 951 putvar CFG_BUILD_TRIPLE
 952 putvar CFG_HOST_TRIPLES
 953 putvar CFG_TARGET_TRIPLES
 954 putvar CFG_C_COMPILER
 955 putvar CFG_LIBDIR
 956 putvar CFG_DISABLE_MANAGE_SUBMODULES
 957 putvar CFG_ANDROID_CROSS_PATH
 958 putvar CFG_MINGW32_CROSS_PATH
 959
 960 if [ ! -z "$CFG_ENABLE_PAX_FLAGS" ]
 961 then
 962     putvar CFG_ENABLE_PAX_FLAGS
 963     putvar CFG_PAXCTL
 964 fi
 965
 966 # Avoid spurious warnings from clang by feeding it original source on
 967 # ccache-miss rather than preprocessed input.
 968 if [ ! -z "$CFG_ENABLE_CCACHE" ] && [ ! -z "$CFG_ENABLE_CLANG" ]
 969 then
 970     CFG_CCACHE_CPP2=1
 971     putvar CFG_CCACHE_CPP2
 972 fi
 973
 974 if [ ! -z "$CFG_ENABLE_CCACHE" ]
 975 then
 976     CFG_CCACHE_BASEDIR=${CFG_SRC_DIR}
 977     putvar CFG_CCACHE_BASEDIR
 978 fi
 979
 980
 981 if [ ! -z $BAD_PANDOC ]
 982 then
 983     CFG_PANDOC=
 984     putvar CFG_PANDOC
 985 fi
 986
 987 if head -n 1 ${CFG_SRC_DIR}src/snapshots.txt | grep -q '^T'
 988 then
 989     CFG_IN_TRANSITION=1
 990     putvar CFG_IN_TRANSITION
 991 fi
 992
 993 # Valgrind is only reliable on Linux. On Windows it doesn't work at all, and
 994 # on the Mac the dynamic linker causes Valgrind to emit a huge stream of
 995 # errors.
 996 if [ $CFG_OSTYPE != unknown-linux-gnu ] && [ $CFG_OSTYPE != apple-darwin ]
 997 then
 998     CFG_BAD_VALGRIND=1
 999     putvar CFG_BAD_VALGRIND
1000 fi
1001
1002 putvar CFG_LLVM_ROOT
1003 putvar CFG_LLVM_SRC_DIR
1004
1005 for t in $CFG_HOST_TRIPLES
1006 do
1007     CFG_LLVM_BUILD_DIR=$(echo CFG_LLVM_BUILD_DIR_${t} | tr - _)
1008     CFG_LLVM_INST_DIR=$(echo CFG_LLVM_INST_DIR_${t} | tr - _)
1009     putvar $CFG_LLVM_BUILD_DIR
1010     putvar $CFG_LLVM_INST_DIR
1011 done
1012
1013 # Munge any paths that appear in config.mk back to posix-y
1014 perl -i.bak -p -e 's@ ([a-zA-Z]):[/\\]@ /\1/@go;' \
1015                -e 's@\\@/@go;' config.tmp
1016 rm -f config.tmp.bak
1017
1018 msg
1019 copy_if_changed ${CFG_SRC_DIR}Makefile.in ./Makefile
1020 move_if_changed config.tmp config.mk
1021 rm -f config.tmp
1022 touch config.stamp
1023
1024 step_msg "complete"