mirror of
https://github.com/rust-lang/rust.git
synced 2024-12-18 03:25:55 +00:00
597e96b549
The right way to link to terminfo varies by linux distribution, so this is making our snapshots less compatible.
1033 lines
25 KiB
Bash
Executable File
1033 lines
25 KiB
Bash
Executable File
#!/bin/sh
|
|
|
|
msg() {
|
|
echo "configure: $1"
|
|
}
|
|
|
|
step_msg() {
|
|
msg
|
|
msg "$1"
|
|
msg
|
|
}
|
|
|
|
warn() {
|
|
echo "configure: WARNING: $1"
|
|
}
|
|
|
|
err() {
|
|
echo "configure: error: $1"
|
|
exit 1
|
|
}
|
|
|
|
need_ok() {
|
|
if [ $? -ne 0 ]
|
|
then
|
|
err $1
|
|
fi
|
|
}
|
|
|
|
need_cmd() {
|
|
if which $1 >/dev/null 2>&1
|
|
then msg "found $1"
|
|
else err "need $1"
|
|
fi
|
|
}
|
|
|
|
make_dir() {
|
|
if [ ! -d $1 ]
|
|
then
|
|
msg "mkdir -p $1"
|
|
mkdir -p $1
|
|
fi
|
|
}
|
|
|
|
copy_if_changed() {
|
|
if cmp -s $1 $2
|
|
then
|
|
msg "leaving $2 unchanged"
|
|
else
|
|
msg "cp $1 $2"
|
|
cp -f $1 $2
|
|
chmod u-w $2 # make copied artifact read-only
|
|
fi
|
|
}
|
|
|
|
move_if_changed() {
|
|
if cmp -s $1 $2
|
|
then
|
|
msg "leaving $2 unchanged"
|
|
else
|
|
msg "mv $1 $2"
|
|
mv -f $1 $2
|
|
chmod u-w $2 # make moved artifact read-only
|
|
fi
|
|
}
|
|
|
|
putvar() {
|
|
local T
|
|
eval T=\$$1
|
|
eval TLEN=\${#$1}
|
|
if [ $TLEN -gt 35 ]
|
|
then
|
|
printf "configure: %-20s := %.35s ...\n" $1 "$T"
|
|
else
|
|
printf "configure: %-20s := %s %s\n" $1 "$T" "$2"
|
|
fi
|
|
printf "%-20s := %s\n" $1 "$T" >>config.tmp
|
|
}
|
|
|
|
probe() {
|
|
local V=$1
|
|
shift
|
|
local P
|
|
local T
|
|
for P
|
|
do
|
|
T=$(which $P 2>&1)
|
|
if [ $? -eq 0 ]
|
|
then
|
|
VER0=$($P --version 2>/dev/null | head -1 \
|
|
| sed -e 's/[^0-9]*\([vV]\?[0-9.]\+[^ ]*\).*/\1/' )
|
|
if [ $? -eq 0 -a "x${VER0}" != "x" ]
|
|
then
|
|
VER="($VER0)"
|
|
else
|
|
VER=""
|
|
fi
|
|
break
|
|
else
|
|
VER=""
|
|
T=""
|
|
fi
|
|
done
|
|
eval $V=\$T
|
|
putvar $V "$VER"
|
|
}
|
|
|
|
probe_need() {
|
|
local V=$1
|
|
probe $*
|
|
eval VV=\$$V
|
|
if [ -z "$VV" ]
|
|
then
|
|
err "needed, but unable to find any of: $*"
|
|
fi
|
|
}
|
|
|
|
validate_opt () {
|
|
for arg in $CFG_CONFIGURE_ARGS
|
|
do
|
|
isArgValid=0
|
|
for option in $BOOL_OPTIONS
|
|
do
|
|
if test --disable-$option = $arg
|
|
then
|
|
isArgValid=1
|
|
fi
|
|
if test --enable-$option = $arg
|
|
then
|
|
isArgValid=1
|
|
fi
|
|
done
|
|
for option in $VAL_OPTIONS
|
|
do
|
|
if echo "$arg" | grep -q -- "--$option="
|
|
then
|
|
isArgValid=1
|
|
fi
|
|
done
|
|
if [ "$arg" = "--help" ]
|
|
then
|
|
echo
|
|
echo "No more help available for Configure options,"
|
|
echo "check the Wiki or join our IRC channel"
|
|
break
|
|
else
|
|
if test $isArgValid -eq 0
|
|
then
|
|
err "Option '$arg' is not recognized"
|
|
fi
|
|
fi
|
|
done
|
|
}
|
|
|
|
valopt() {
|
|
VAL_OPTIONS="$VAL_OPTIONS $1"
|
|
|
|
local OP=$1
|
|
local DEFAULT=$2
|
|
shift
|
|
shift
|
|
local DOC="$*"
|
|
if [ $HELP -eq 0 ]
|
|
then
|
|
local UOP=$(echo $OP | tr '[:lower:]' '[:upper:]' | tr '\-' '\_')
|
|
local V="CFG_${UOP}"
|
|
eval $V="$DEFAULT"
|
|
for arg in $CFG_CONFIGURE_ARGS
|
|
do
|
|
if echo "$arg" | grep -q -- "--$OP="
|
|
then
|
|
val=$(echo "$arg" | cut -f2 -d=)
|
|
eval $V=$val
|
|
fi
|
|
done
|
|
putvar $V
|
|
else
|
|
if [ -z "$DEFAULT" ]
|
|
then
|
|
DEFAULT="<none>"
|
|
fi
|
|
OP="${OP}=[${DEFAULT}]"
|
|
printf " --%-30s %s\n" "$OP" "$DOC"
|
|
fi
|
|
}
|
|
|
|
opt() {
|
|
BOOL_OPTIONS="$BOOL_OPTIONS $1"
|
|
|
|
local OP=$1
|
|
local DEFAULT=$2
|
|
shift
|
|
shift
|
|
local DOC="$*"
|
|
local FLAG=""
|
|
|
|
if [ $DEFAULT -eq 0 ]
|
|
then
|
|
FLAG="enable"
|
|
else
|
|
FLAG="disable"
|
|
DOC="don't $DOC"
|
|
fi
|
|
|
|
if [ $HELP -eq 0 ]
|
|
then
|
|
for arg in $CFG_CONFIGURE_ARGS
|
|
do
|
|
if [ "$arg" = "--${FLAG}-${OP}" ]
|
|
then
|
|
OP=$(echo $OP | tr 'a-z-' 'A-Z_')
|
|
FLAG=$(echo $FLAG | tr 'a-z' 'A-Z')
|
|
local V="CFG_${FLAG}_${OP}"
|
|
eval $V=1
|
|
putvar $V
|
|
fi
|
|
done
|
|
else
|
|
if [ ! -z "$META" ]
|
|
then
|
|
OP="$OP=<$META>"
|
|
fi
|
|
printf " --%-30s %s\n" "$FLAG-$OP" "$DOC"
|
|
fi
|
|
}
|
|
|
|
msg "looking for configure programs"
|
|
need_cmd cmp
|
|
need_cmd mkdir
|
|
need_cmd printf
|
|
need_cmd cut
|
|
need_cmd head
|
|
need_cmd grep
|
|
need_cmd xargs
|
|
need_cmd cp
|
|
need_cmd find
|
|
need_cmd uname
|
|
need_cmd date
|
|
need_cmd tr
|
|
need_cmd sed
|
|
need_cmd file
|
|
|
|
msg "inspecting environment"
|
|
|
|
CFG_OSTYPE=$(uname -s)
|
|
CFG_CPUTYPE=$(uname -m)
|
|
|
|
if [ $CFG_OSTYPE = Darwin -a $CFG_CPUTYPE = i386 ]
|
|
then
|
|
# Darwin's `uname -s` lies and always returns i386. We have to use sysctl
|
|
# instead.
|
|
if sysctl hw.optional.x86_64 | grep -q ': 1'
|
|
then
|
|
CFG_CPUTYPE=x86_64
|
|
fi
|
|
fi
|
|
|
|
# The goal here is to come up with the same triple as LLVM would,
|
|
# at least for the subset of platforms we're willing to target.
|
|
|
|
case $CFG_OSTYPE in
|
|
|
|
Linux)
|
|
CFG_OSTYPE=unknown-linux-gnu
|
|
;;
|
|
|
|
FreeBSD)
|
|
CFG_OSTYPE=unknown-freebsd
|
|
;;
|
|
|
|
Darwin)
|
|
CFG_OSTYPE=apple-darwin
|
|
;;
|
|
|
|
MINGW32*)
|
|
CFG_OSTYPE=pc-mingw32
|
|
;;
|
|
# Thad's Cygwin identifers below
|
|
|
|
# Vista 32 bit
|
|
CYGWIN_NT-6.0)
|
|
CFG_OSTYPE=pc-mingw32
|
|
CFG_CPUTYPE=i686
|
|
;;
|
|
|
|
# Vista 64 bit
|
|
CYGWIN_NT-6.0-WOW64)
|
|
CFG_OSTYPE=w64-mingw32
|
|
CFG_CPUTYPE=x86_64
|
|
;;
|
|
|
|
# Win 7 32 bit
|
|
CYGWIN_NT-6.1)
|
|
CFG_OSTYPE=pc-mingw32
|
|
CFG_CPUTYPE=i686
|
|
;;
|
|
|
|
# Win 7 64 bit
|
|
CYGWIN_NT-6.1-WOW64)
|
|
CFG_OSTYPE=w64-mingw32
|
|
CFG_CPUTYPE=x86_64
|
|
;;
|
|
|
|
# We do not detect other OS such as XP/2003 using 64 bit using uname.
|
|
# 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.
|
|
*)
|
|
err "unknown OS type: $CFG_OSTYPE"
|
|
;;
|
|
esac
|
|
|
|
|
|
case $CFG_CPUTYPE in
|
|
|
|
i386 | i486 | i686 | i786 | x86)
|
|
CFG_CPUTYPE=i686
|
|
;;
|
|
|
|
xscale | arm)
|
|
CFG_CPUTYPE=arm
|
|
;;
|
|
|
|
x86_64 | x86-64 | x64 | amd64)
|
|
CFG_CPUTYPE=x86_64
|
|
;;
|
|
|
|
*)
|
|
err "unknown CPU type: $CFG_CPUTYPE"
|
|
esac
|
|
|
|
# Detect 64 bit linux systems with 32 bit userland and force 32 bit compilation
|
|
if [ $CFG_OSTYPE = unknown-linux-gnu -a $CFG_CPUTYPE = x86_64 ]
|
|
then
|
|
file -L "$SHELL" | grep -q "x86[_-]64"
|
|
if [ $? != 0 ]; then
|
|
CFG_CPUTYPE=i686
|
|
fi
|
|
fi
|
|
|
|
|
|
DEFAULT_BUILD_TRIPLE="${CFG_CPUTYPE}-${CFG_OSTYPE}"
|
|
|
|
CFG_SRC_DIR="$(cd $(dirname $0) && pwd)/"
|
|
CFG_BUILD_DIR="$(pwd)/"
|
|
CFG_SELF=${CFG_SRC_DIR}$(basename $0)
|
|
CFG_CONFIGURE_ARGS="$@"
|
|
|
|
OPTIONS=""
|
|
HELP=0
|
|
if [ "$1" = "--help" ]
|
|
then
|
|
HELP=1
|
|
shift
|
|
echo
|
|
echo "Usage: $CFG_SELF [options]"
|
|
echo
|
|
echo "Options:"
|
|
echo
|
|
else
|
|
msg "recreating config.tmp"
|
|
echo '' >config.tmp
|
|
|
|
step_msg "processing $CFG_SELF args"
|
|
fi
|
|
|
|
BOOL_OPTIONS=""
|
|
VAL_OPTIONS=""
|
|
|
|
opt sharedstd 1 "build libstd as a shared library"
|
|
opt valgrind 0 "run tests with valgrind (memcheck by default)"
|
|
opt helgrind 0 "run tests with helgrind instead of memcheck"
|
|
opt docs 1 "build documentation"
|
|
opt optimize 1 "build optimized rust code"
|
|
opt optimize-cxx 1 "build optimized C++ code"
|
|
opt optimize-llvm 1 "build optimized LLVM"
|
|
opt optimize-tests 1 "build tests with optimizations"
|
|
opt llvm-assertions 1 "build LLVM with assertions"
|
|
opt debug 1 "build with extra debug fun"
|
|
opt ratchet-bench 0 "ratchet benchmarks"
|
|
opt fast-make 0 "use .gitmodules as timestamp for submodule deps"
|
|
opt manage-submodules 1 "let the build manage the git submodules"
|
|
opt mingw-cross 0 "cross-compile for win32 using mingw"
|
|
opt clang 0 "prefer clang to gcc for building the runtime"
|
|
opt ccache 0 "invoke gcc/clang via ccache to reuse object files between builds"
|
|
opt local-rust 0 "use an installed rustc rather than downloading a snapshot"
|
|
opt pax-flags 0 "apply PaX flags to rustc binaries (required for GRSecurity/PaX-patched kernels)"
|
|
valopt prefix "/usr/local" "set installation prefix"
|
|
valopt local-rust-root "/usr/local" "set prefix for local rust binary"
|
|
valopt llvm-root "" "set LLVM root"
|
|
valopt build-triple "${DEFAULT_BUILD_TRIPLE}" "LLVM build triple"
|
|
valopt host-triples "${CFG_BUILD_TRIPLE}" "LLVM host triples"
|
|
valopt target-triples "${CFG_HOST_TRIPLES}" "LLVM target triples"
|
|
valopt android-cross-path "/opt/ndk_standalone" "Android NDK standalone path"
|
|
valopt mingw32-cross-path "" "MinGW32 cross compiler path"
|
|
|
|
# Validate Options
|
|
step_msg "validating $CFG_SELF args"
|
|
validate_opt
|
|
|
|
if [ $HELP -eq 1 ]
|
|
then
|
|
echo
|
|
exit 0
|
|
fi
|
|
|
|
|
|
step_msg "looking for build programs"
|
|
|
|
probe_need CFG_PERL perl
|
|
probe_need CFG_CURLORWGET curl wget
|
|
probe_need CFG_PYTHON python2.7 python2.6 python2 python
|
|
|
|
python_version=$($CFG_PYTHON -V 2>&1)
|
|
if [ $(echo $python_version | grep -c '^Python 2\.[4567]') -ne 1 ]; then
|
|
err "Found $python_version, but LLVM requires Python 2.4-2.7"
|
|
fi
|
|
|
|
# If we have no git directory then we are probably a tarball distribution
|
|
# and shouldn't attempt to load submodules
|
|
if [ ! -e ${CFG_SRC_DIR}.git ]
|
|
then
|
|
probe CFG_GIT git
|
|
msg "git: no git directory. disabling submodules"
|
|
CFG_DISABLE_MANAGE_SUBMODULES=1
|
|
else
|
|
probe_need CFG_GIT git
|
|
fi
|
|
|
|
probe CFG_CLANG clang++
|
|
probe CFG_CCACHE ccache
|
|
probe CFG_GCC gcc
|
|
probe CFG_LD ld
|
|
probe CFG_VALGRIND valgrind
|
|
probe CFG_PERF perf
|
|
probe CFG_ISCC iscc
|
|
probe CFG_LLNEXTGEN LLnextgen
|
|
probe CFG_PANDOC pandoc
|
|
probe CFG_PDFLATEX pdflatex
|
|
probe CFG_XETEX xetex
|
|
probe CFG_LUATEX luatex
|
|
probe CFG_NODE nodejs node
|
|
probe CFG_GDB gdb
|
|
if [ "$CFG_OSTYPE" = "unknown-linux-gnu" ]
|
|
then
|
|
probe CFG_PAXCTL paxctl /sbin/paxctl
|
|
probe CFG_ZCAT zcat
|
|
fi
|
|
|
|
step_msg "looking for target specific programs"
|
|
|
|
probe CFG_ADB adb
|
|
|
|
if [ ! -z "$CFG_PANDOC" ]
|
|
then
|
|
PV_MAJOR_MINOR=$(pandoc --version | grep '^pandoc ' |
|
|
# extract the first 2 version fields, ignore everything else
|
|
sed 's/pandoc \([0-9]*\)\.\([0-9]*\).*/\1 \2/')
|
|
|
|
# these patterns are shell globs, *not* regexps
|
|
PV_MAJOR=${PV_MAJOR_MINOR% *}
|
|
PV_MINOR=${PV_MAJOR_MINOR#* }
|
|
if [ "$PV_MAJOR" -lt "1" ] || [ "$PV_MINOR" -lt "8" ]
|
|
then
|
|
step_msg "pandoc $PV_MAJOR.$PV_MINOR is too old. disabling"
|
|
BAD_PANDOC=1
|
|
fi
|
|
fi
|
|
|
|
if [ "$CFG_OSTYPE" = "unknown-linux-gnu" ]
|
|
then
|
|
if [ ! -z "$CFG_ENABLE_PAX_FLAGS" -a -z "$CFG_PAXCTL" ]
|
|
then
|
|
err "enabled PaX markings but no paxctl binary found"
|
|
fi
|
|
|
|
if [ -z "$CFG_DISABLE_PAX_FLAGS" ]
|
|
then
|
|
# GRSecurity/PaX detection. This can be very flaky.
|
|
GRSEC_DETECTED=
|
|
|
|
# /dev/grsec only exists if CONFIG_GRKERNSEC_NO_RBAC is not set.
|
|
# /proc/sys/kernel/grsecurity is not available if ÇONFIG_GRKERNSEC_SYSCTL is not set.
|
|
if [ -e /dev/grsec -o -d /proc/sys/kernel/grsecurity ]
|
|
then
|
|
GRSEC_DETECTED=1
|
|
# /proc/config.gz is normally only available to root, and only if CONFIG_IKCONFIG_PROC has been set.
|
|
elif [ -r /proc/config.gz -a ! -z "$CFG_ZCAT" ]
|
|
then
|
|
if "$CFG_ZCAT" /proc/config.gz | grep --quiet "CONFIG_GRKERNSEC=y"
|
|
then
|
|
GRSEC_DETECTED=1
|
|
fi
|
|
# Flaky.
|
|
elif grep --quiet grsec /proc/version
|
|
then
|
|
GRSEC_DETECTED=1
|
|
fi
|
|
|
|
if [ ! -z "$GRSEC_DETECTED" ]
|
|
then
|
|
step_msg "GRSecurity: yes"
|
|
if [ ! -z "$CFG_PAXCTL" ]
|
|
then
|
|
CFG_ENABLE_PAX_FLAGS=1
|
|
else
|
|
warn "GRSecurity kernel detected but no paxctl binary found: not setting CFG_ENABLE_PAX_FLAGS"
|
|
fi
|
|
else
|
|
step_msg "GRSecurity: no"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if [ ! -z "$CFG_ENABLE_LOCAL_RUST" ]
|
|
then
|
|
if [ ! -f ${CFG_LOCAL_RUST_ROOT}/bin/rustc ]
|
|
then
|
|
err "no local rust to use"
|
|
else
|
|
LRV=`${CFG_LOCAL_RUST_ROOT}/bin/rustc --version`
|
|
step_msg "using rustc at: ${CFG_LOCAL_RUST_ROOT} with version: " $LRV
|
|
fi
|
|
fi
|
|
|
|
# Force freebsd to build with clang; gcc doesn't like us there
|
|
if [ $CFG_OSTYPE = unknown-freebsd ]
|
|
then
|
|
step_msg "on FreeBSD, forcing use of clang"
|
|
CFG_ENABLE_CLANG=1
|
|
putvar CFG_ENABLE_CLANG
|
|
fi
|
|
|
|
|
|
if [ -z "$CFG_ENABLE_CLANG" -a -z "$CFG_GCC" ]
|
|
then
|
|
err "either clang or gcc is required"
|
|
fi
|
|
|
|
if [ ! -z "$CFG_LLVM_ROOT" -a -e "$CFG_LLVM_ROOT/bin/llvm-config" ]
|
|
then
|
|
step_msg "using custom LLVM at $CFG_LLVM_ROOT"
|
|
|
|
LLVM_CONFIG="$CFG_LLVM_ROOT/bin/llvm-config"
|
|
LLVM_VERSION=$($LLVM_CONFIG --version)
|
|
|
|
case $LLVM_VERSION in
|
|
(3.3|3.3svn|3.2|3.2svn)
|
|
msg "found ok version of LLVM: $LLVM_VERSION"
|
|
;;
|
|
(*)
|
|
err "bad LLVM version: $LLVM_VERSION, need >=3.0svn"
|
|
;;
|
|
esac
|
|
fi
|
|
|
|
if [ ! -z "$CFG_ENABLE_CLANG" ]
|
|
then
|
|
if [ -z "$CFG_CLANG" ]
|
|
then
|
|
err "clang requested but not found"
|
|
fi
|
|
CFG_CLANG_VERSION=$("$CFG_CLANG" \
|
|
--version \
|
|
| grep version \
|
|
| sed 's/.*\(version .*\)/\1/; s/.*based on \(LLVM .*\))/\1/' \
|
|
| cut -d ' ' -f 2)
|
|
|
|
case $CFG_CLANG_VERSION in
|
|
(3.0svn | 3.0 | 3.1* | 3.2* | 3.3* | 3.4* )
|
|
step_msg "found ok version of CLANG: $CFG_CLANG_VERSION"
|
|
CFG_C_COMPILER="clang"
|
|
;;
|
|
(*)
|
|
err "bad CLANG version: $CFG_CLANG_VERSION, need >=3.0svn"
|
|
;;
|
|
esac
|
|
else
|
|
CFG_C_COMPILER="gcc"
|
|
fi
|
|
|
|
if [ ! -z "$CFG_ENABLE_CCACHE" ]
|
|
then
|
|
if [ -z "$CFG_CCACHE" ]
|
|
then
|
|
err "ccache requested but not found"
|
|
fi
|
|
|
|
CFG_C_COMPILER="ccache $CFG_C_COMPILER"
|
|
fi
|
|
|
|
# a little post-processing of various config values
|
|
|
|
CFG_PREFIX=${CFG_PREFIX%/}
|
|
CFG_HOST_TRIPLES="$(echo $CFG_HOST_TRIPLES | tr ',' ' ')"
|
|
CFG_TARGET_TRIPLES="$(echo $CFG_TARGET_TRIPLES | tr ',' ' ')"
|
|
CFG_SUPPORTED_TARGET_TRIPLES="$(grep ^CC_*=* $CFG_SRC_DIR/mk/platform.mk | sed -e 's/^CC_//' -e 's/\([^=]*\).*/\1/' | xargs)"
|
|
|
|
# copy host-triples to target-triples so that hosts are a subset of targets
|
|
V_TEMP=""
|
|
for i in $CFG_HOST_TRIPLES $CFG_TARGET_TRIPLES;
|
|
do
|
|
echo "$V_TEMP" | grep -qF $i || V_TEMP="$V_TEMP${V_TEMP:+ }$i"
|
|
done
|
|
CFG_TARGET_TRIPLES=$V_TEMP
|
|
|
|
# check target-specific tool-chains
|
|
for i in $CFG_TARGET_TRIPLES
|
|
do
|
|
L_CHECK=false
|
|
for j in $CFG_SUPPORTED_TARGET_TRIPLES
|
|
do
|
|
if [ $i = $j ]
|
|
then
|
|
L_CHECK=true
|
|
fi
|
|
done
|
|
|
|
if [ $L_CHECK = false ]
|
|
then
|
|
err "unsupported target triples \"$i\" found"
|
|
fi
|
|
|
|
case $i in
|
|
arm-linux-androideabi)
|
|
|
|
if [ ! -f $CFG_ANDROID_CROSS_PATH/bin/arm-linux-androideabi-gcc ]
|
|
then
|
|
err "NDK $CFG_ANDROID_CROSS_PATH/bin/arm-linux-androideabi-gcc not found"
|
|
fi
|
|
if [ ! -f $CFG_ANDROID_CROSS_PATH/bin/arm-linux-androideabi-g++ ]
|
|
then
|
|
err "NDK $CFG_ANDROID_CROSS_PATH/bin/arm-linux-androideabi-g++ not found"
|
|
fi
|
|
if [ ! -f $CFG_ANDROID_CROSS_PATH/bin/arm-linux-androideabi-ar ]
|
|
then
|
|
err "NDK $CFG_ANDROID_CROSS_PATH/bin/arm-linux-androideabi-ar not found"
|
|
fi
|
|
;;
|
|
|
|
*)
|
|
;;
|
|
esac
|
|
done
|
|
|
|
if [ -z "$CFG_ENABLE_CLANG" -a -z "$CFG_GCC" ]
|
|
then
|
|
err "either clang or gcc is required"
|
|
fi
|
|
|
|
if [ ! -z "$CFG_PERF" ]
|
|
then
|
|
HAVE_PERF_LOGFD=`$CFG_PERF stat --log-fd 2>&1 | grep 'unknown option'`
|
|
if [ -z "$HAVE_PERF_LOGFD" ];
|
|
then
|
|
CFG_PERF_WITH_LOGFD=1
|
|
putvar CFG_PERF_WITH_LOGFD
|
|
fi
|
|
fi
|
|
|
|
step_msg "making directories"
|
|
|
|
for i in \
|
|
doc doc/std doc/extra \
|
|
dl tmp
|
|
do
|
|
make_dir $i
|
|
done
|
|
|
|
for t in $CFG_HOST_TRIPLES
|
|
do
|
|
make_dir $t/llvm
|
|
done
|
|
|
|
for t in $CFG_HOST_TRIPLES
|
|
do
|
|
make_dir $t/rustllvm
|
|
done
|
|
|
|
for t in $CFG_TARGET_TRIPLES
|
|
do
|
|
make_dir $t/rt
|
|
for s in 0 1 2 3
|
|
do
|
|
make_dir $t/rt/stage$s
|
|
for i in \
|
|
isaac linenoise sync test \
|
|
arch/i386 arch/x86_64 arch/arm arch/mips \
|
|
libuv libuv/src/ares libuv/src/eio libuv/src/ev \
|
|
jemalloc
|
|
do
|
|
make_dir $t/rt/stage$s/$i
|
|
done
|
|
done
|
|
done
|
|
|
|
# On windows we just store the libraries in the bin directory because
|
|
# there's no rpath
|
|
# FIXME: Thise needs to parameterized over target triples. Do it in platform.mk
|
|
CFG_LIBDIR=lib
|
|
if [ "$CFG_OSTYPE" = "pc-mingw32" ]
|
|
then
|
|
CFG_LIBDIR=bin
|
|
fi
|
|
|
|
for h in $CFG_HOST_TRIPLES
|
|
do
|
|
for t in $CFG_TARGET_TRIPLES
|
|
do
|
|
for i in 0 1 2 3
|
|
do
|
|
# host bin dir
|
|
make_dir $h/stage$i/bin
|
|
|
|
# host lib dir
|
|
make_dir $h/stage$i/$CFG_LIBDIR
|
|
|
|
# host test dir
|
|
make_dir $h/stage$i/test
|
|
|
|
# target bin dir
|
|
make_dir $h/stage$i/$CFG_LIBDIR/rustc/$t/bin
|
|
|
|
# target lib dir
|
|
make_dir $h/stage$i/$CFG_LIBDIR/rustc/$t/$CFG_LIBDIR
|
|
done
|
|
done
|
|
|
|
make_dir $h/test/run-pass
|
|
make_dir $h/test/run-pass-fulldeps
|
|
make_dir $h/test/run-fail
|
|
make_dir $h/test/compile-fail
|
|
make_dir $h/test/bench
|
|
make_dir $h/test/perf
|
|
make_dir $h/test/pretty
|
|
make_dir $h/test/debug-info
|
|
make_dir $h/test/codegen
|
|
make_dir $h/test/doc-tutorial
|
|
make_dir $h/test/doc-tutorial-ffi
|
|
make_dir $h/test/doc-tutorial-macros
|
|
make_dir $h/test/doc-tutorial-borrowed-ptr
|
|
make_dir $h/test/doc-tutorial-container
|
|
make_dir $h/test/doc-tutorial-tasks
|
|
make_dir $h/test/doc-tutorial-conditions
|
|
make_dir $h/test/doc-rust
|
|
done
|
|
|
|
# Configure submodules
|
|
step_msg "configuring submodules"
|
|
|
|
# Have to be in the top of src directory for this
|
|
if [ -z $CFG_DISABLE_MANAGE_SUBMODULES ]
|
|
then
|
|
cd ${CFG_SRC_DIR}
|
|
|
|
msg "git: submodule sync"
|
|
"${CFG_GIT}" submodule sync
|
|
|
|
msg "git: submodule update"
|
|
"${CFG_GIT}" submodule update --init
|
|
need_ok "git failed"
|
|
|
|
msg "git: submodule foreach sync"
|
|
"${CFG_GIT}" submodule foreach --recursive 'if test -e .gitmodules; then git submodule sync; fi'
|
|
need_ok "git failed"
|
|
|
|
msg "git: submodule foreach update"
|
|
"${CFG_GIT}" submodule update --init --recursive
|
|
need_ok "git failed"
|
|
|
|
# NB: this is just for the sake of getting the submodule SHA1 values
|
|
# and status written into the build log.
|
|
msg "git: submodule status"
|
|
"${CFG_GIT}" submodule status --recursive
|
|
|
|
msg "git: submodule clobber"
|
|
"${CFG_GIT}" submodule foreach --recursive git clean -dxf
|
|
need_ok "git failed"
|
|
"${CFG_GIT}" submodule foreach --recursive git checkout .
|
|
need_ok "git failed"
|
|
|
|
cd ${CFG_BUILD_DIR}
|
|
fi
|
|
|
|
# Configure llvm, only if necessary
|
|
step_msg "looking at LLVM"
|
|
CFG_LLVM_SRC_DIR=${CFG_SRC_DIR}src/llvm/
|
|
for t in $CFG_HOST_TRIPLES
|
|
do
|
|
do_reconfigure=1
|
|
|
|
if [ -z $CFG_LLVM_ROOT ]
|
|
then
|
|
LLVM_BUILD_DIR=${CFG_BUILD_DIR}$t/llvm
|
|
if [ ! -z "$CFG_DISABLE_OPTIMIZE_LLVM" ]
|
|
then
|
|
LLVM_DBG_OPTS="--enable-debug-symbols --disable-optimized"
|
|
# Just use LLVM straight from its build directory to
|
|
# avoid 'make install' time
|
|
LLVM_INST_DIR=$LLVM_BUILD_DIR/Debug
|
|
else
|
|
LLVM_DBG_OPTS="--enable-optimized"
|
|
LLVM_INST_DIR=$LLVM_BUILD_DIR/Release
|
|
fi
|
|
if [ ! -z "$CFG_DISABLE_LLVM_ASSERTIONS" ]
|
|
then
|
|
LLVM_ASSERTION_OPTS="--disable-assertions"
|
|
else
|
|
LLVM_ASSERTION_OPTS="--enable-assertions"
|
|
LLVM_INST_DIR=${LLVM_INST_DIR}+Asserts
|
|
fi
|
|
else
|
|
msg "not reconfiguring LLVM, external LLVM root"
|
|
# The user is using their own LLVM
|
|
LLVM_BUILD_DIR=
|
|
LLVM_INST_DIR=$CFG_LLVM_ROOT
|
|
do_reconfigure=0
|
|
fi
|
|
|
|
|
|
if [ ${do_reconfigure} -ne 0 ]
|
|
then
|
|
# because git is hilarious, it might have put the module index
|
|
# in a couple places.
|
|
index1="${CFG_SRC_DIR}.git/modules/src/llvm/index"
|
|
index2="${CFG_SRC_DIR}src/llvm/.git/index"
|
|
for index in ${index1} ${index2}
|
|
do
|
|
config_status="${LLVM_BUILD_DIR}/config.status"
|
|
if test -e ${index} -a \
|
|
-e ${config_status} -a \
|
|
${config_status} -nt ${index}
|
|
then
|
|
msg "not reconfiguring LLVM, config.status is fresh"
|
|
do_reconfigure=0
|
|
fi
|
|
done
|
|
fi
|
|
|
|
if [ ${do_reconfigure} -ne 0 ]
|
|
then
|
|
msg "configuring LLVM for $t"
|
|
|
|
LLVM_TARGETS="--enable-targets=x86,x86_64,arm,mips"
|
|
LLVM_BUILD="--build=$t"
|
|
LLVM_HOST="--host=$t"
|
|
LLVM_TARGET="--target=$t"
|
|
|
|
# Disable unused LLVM features
|
|
LLVM_OPTS="$LLVM_DBG_OPTS $LLVM_ASSERTION_OPTS --disable-docs --enable-bindings=none"
|
|
# Disable term-info, linkage of which comes in multiple forms,
|
|
# making our snapshots incompatible (#9334)
|
|
LLVM_OPTS="$LLVM_OPTS --disable-terminfo"
|
|
|
|
case "$CFG_C_COMPILER" in
|
|
("ccache clang")
|
|
LLVM_CXX_32="ccache clang++ -m32 -Qunused-arguments"
|
|
LLVM_CC_32="ccache clang -m32 -Qunused-arguments"
|
|
|
|
LLVM_CXX_64="ccache clang++ -Qunused-arguments"
|
|
LLVM_CC_64="ccache clang -Qunused-arguments"
|
|
;;
|
|
("clang")
|
|
LLVM_CXX_32="clang++ -m32"
|
|
LLVM_CC_32="clang -m32"
|
|
|
|
LLVM_CXX_64="clang++"
|
|
LLVM_CC_64="clang"
|
|
;;
|
|
("ccache gcc")
|
|
LLVM_CXX_32="ccache g++ -m32"
|
|
LLVM_CC_32="ccache gcc -m32"
|
|
|
|
LLVM_CXX_64="ccache g++"
|
|
LLVM_CC_64="ccache gcc"
|
|
;;
|
|
("gcc")
|
|
LLVM_CXX_32="g++ -m32"
|
|
LLVM_CC_32="gcc -m32"
|
|
|
|
LLVM_CXX_64="g++"
|
|
LLVM_CC_64="gcc"
|
|
esac
|
|
|
|
LLVM_CFLAGS_32="-m32"
|
|
LLVM_CXXFLAGS_32="-m32"
|
|
LLVM_LDFLAGS_32="-m32"
|
|
|
|
LLVM_CFLAGS_64=""
|
|
LLVM_CXXFLAGS_64=""
|
|
LLVM_LDFLAGS_64=""
|
|
|
|
if echo $t | grep -q x86_64
|
|
then
|
|
LLVM_CXX=$LLVM_CXX_64
|
|
LLVM_CC=$LLVM_CC_64
|
|
LLVM_CFLAGS=$LLVM_CFLAGS_64
|
|
LLVM_CXXFLAGS=$LLVM_CXXFLAGS_64
|
|
LLVM_LDFLAGS=$LLVM_LDFLAGS_64
|
|
else
|
|
LLVM_CXX=$LLVM_CXX_32
|
|
LLVM_CC=$LLVM_CC_32
|
|
LLVM_CFLAGS=$LLVM_CFLAGS_32
|
|
LLVM_CXXFLAGS=$LLVM_CXXFLAGS_32
|
|
LLVM_LDFLAGS=$LLVM_LDFLAGS_32
|
|
fi
|
|
|
|
CXX=$LLVM_CXX
|
|
CC=$LLVM_CC
|
|
CFLAGS=$LLVM_CFLAGS
|
|
CXXFLAGS=$LLVM_CXXFLAGS
|
|
LDFLAGS=$LLVM_LDFLAGS
|
|
|
|
LLVM_FLAGS="$LLVM_TARGETS $LLVM_OPTS $LLVM_BUILD \
|
|
$LLVM_HOST $LLVM_TARGET --with-python=$CFG_PYTHON"
|
|
|
|
msg "configuring LLVM with:"
|
|
msg "$LLVM_FLAGS"
|
|
|
|
export CXX
|
|
export CC
|
|
export CFLAGS
|
|
export CXXFLAGS
|
|
export LDFLAGS
|
|
|
|
cd $LLVM_BUILD_DIR
|
|
case $CFG_SRC_DIR in
|
|
/* | [a-z]:* | [A-Z]:*)
|
|
${CFG_LLVM_SRC_DIR}configure $LLVM_FLAGS
|
|
;;
|
|
*)
|
|
${CFG_BUILD_DIR}${CFG_LLVM_SRC_DIR}configure \
|
|
$LLVM_FLAGS
|
|
;;
|
|
esac
|
|
need_ok "LLVM configure failed"
|
|
|
|
cd $CFG_BUILD_DIR
|
|
fi
|
|
|
|
# Construct variables for LLVM build and install directories for
|
|
# each target. These will be named
|
|
# CFG_LLVM_BUILD_DIR_${target_triple} but all the hyphens in
|
|
# target_triple will be converted to underscore, because bash
|
|
# variables can't contain hyphens. The makefile will then have to
|
|
# convert back.
|
|
CFG_LLVM_BUILD_DIR=$(echo CFG_LLVM_BUILD_DIR_${t} | tr - _)
|
|
CFG_LLVM_INST_DIR=$(echo CFG_LLVM_INST_DIR_${t} | tr - _)
|
|
eval ${CFG_LLVM_BUILD_DIR}="'$LLVM_BUILD_DIR'"
|
|
eval ${CFG_LLVM_INST_DIR}="'$LLVM_INST_DIR'"
|
|
done
|
|
|
|
|
|
step_msg "writing configuration"
|
|
|
|
putvar CFG_SRC_DIR
|
|
putvar CFG_BUILD_DIR
|
|
putvar CFG_OSTYPE
|
|
putvar CFG_CPUTYPE
|
|
putvar CFG_CONFIGURE_ARGS
|
|
putvar CFG_PREFIX
|
|
putvar CFG_BUILD_TRIPLE
|
|
putvar CFG_HOST_TRIPLES
|
|
putvar CFG_TARGET_TRIPLES
|
|
putvar CFG_C_COMPILER
|
|
putvar CFG_LIBDIR
|
|
putvar CFG_DISABLE_MANAGE_SUBMODULES
|
|
putvar CFG_ANDROID_CROSS_PATH
|
|
putvar CFG_MINGW32_CROSS_PATH
|
|
|
|
if [ ! -z "$CFG_ENABLE_PAX_FLAGS" ]
|
|
then
|
|
putvar CFG_ENABLE_PAX_FLAGS
|
|
putvar CFG_PAXCTL
|
|
fi
|
|
|
|
# Avoid spurious warnings from clang by feeding it original source on
|
|
# ccache-miss rather than preprocessed input.
|
|
if [ ! -z "$CFG_ENABLE_CCACHE" ] && [ ! -z "$CFG_ENABLE_CLANG" ]
|
|
then
|
|
CFG_CCACHE_CPP2=1
|
|
putvar CFG_CCACHE_CPP2
|
|
fi
|
|
|
|
if [ ! -z "$CFG_ENABLE_CCACHE" ]
|
|
then
|
|
CFG_CCACHE_BASEDIR=${CFG_SRC_DIR}
|
|
putvar CFG_CCACHE_BASEDIR
|
|
fi
|
|
|
|
|
|
if [ ! -z $BAD_PANDOC ]
|
|
then
|
|
CFG_PANDOC=
|
|
putvar CFG_PANDOC
|
|
fi
|
|
|
|
if head -n 1 ${CFG_SRC_DIR}src/snapshots.txt | grep -q '^T'
|
|
then
|
|
CFG_IN_TRANSITION=1
|
|
putvar CFG_IN_TRANSITION
|
|
fi
|
|
|
|
# Valgrind is only reliable on Linux. On Windows it doesn't work at all, and
|
|
# on the Mac the dynamic linker causes Valgrind to emit a huge stream of
|
|
# errors.
|
|
if [ $CFG_OSTYPE != unknown-linux-gnu ] && [ $CFG_OSTYPE != apple-darwin ]
|
|
then
|
|
CFG_BAD_VALGRIND=1
|
|
putvar CFG_BAD_VALGRIND
|
|
fi
|
|
|
|
putvar CFG_LLVM_ROOT
|
|
putvar CFG_LLVM_SRC_DIR
|
|
|
|
for t in $CFG_HOST_TRIPLES
|
|
do
|
|
CFG_LLVM_BUILD_DIR=$(echo CFG_LLVM_BUILD_DIR_${t} | tr - _)
|
|
CFG_LLVM_INST_DIR=$(echo CFG_LLVM_INST_DIR_${t} | tr - _)
|
|
putvar $CFG_LLVM_BUILD_DIR
|
|
putvar $CFG_LLVM_INST_DIR
|
|
done
|
|
|
|
# Munge any paths that appear in config.mk back to posix-y
|
|
perl -i.bak -p -e 's@ ([a-zA-Z]):[/\\]@ /\1/@go;' \
|
|
-e 's@\\@/@go;' config.tmp
|
|
rm -f config.tmp.bak
|
|
|
|
msg
|
|
copy_if_changed ${CFG_SRC_DIR}Makefile.in ./Makefile
|
|
move_if_changed config.tmp config.mk
|
|
rm -f config.tmp
|
|
touch config.stamp
|
|
|
|
step_msg "complete"
|