mirror of
https://github.com/rust-lang/rust.git
synced 2024-11-27 17:24:06 +00:00
acdee8b904
The goal of the snapshot bots is to produce binaries which can run in as many locations as possible. Currently we build on Centos 6 for this reason, but with LLVM's update to C++11, this reduces the number of platforms that we could possibly run on. This adds a --enable-llvm-static-stdcpp option to the ./configure script for Rust which will enable building a librustc with a static dependence on libstdc++. This normally isn't necessary, but this option can be used on the snapshot builders in order to continue to make binaries which should be able to run in as many locations as possible.
1117 lines
29 KiB
Bash
Executable File
1117 lines
29 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 command -v $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=$(command -v $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
|
|
;;
|
|
|
|
MINGW64*)
|
|
# msys2, MSYSTEM=MINGW64
|
|
CFG_OSTYPE=w64-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="${CFG_CPUTYPE}-${CFG_OSTYPE}"
|
|
|
|
CFG_SRC_DIR="$(cd $(dirname $0) && pwd)/"
|
|
CFG_BUILD_DIR="$(pwd)/"
|
|
CFG_SELF="$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 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)"
|
|
opt inject-std-version 1 "inject the current compiler version of libstd into programs"
|
|
opt llvm-static-stdcpp 0 "statically link to libstdc++ for LLVM"
|
|
opt rpath 1 "build rpaths into rustc itself"
|
|
opt nightly 0 "build nightly packages"
|
|
opt verify-install 1 "verify installed binaries work"
|
|
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 android-cross-path "/opt/ndk_standalone" "Android NDK standalone path"
|
|
valopt mingw32-cross-path "" "MinGW32 cross compiler path"
|
|
|
|
valopt build "${DEFAULT_BUILD}" "GNUs ./configure syntax LLVM build triple"
|
|
valopt host "${CFG_BUILD}" "GNUs ./configure syntax LLVM host triples"
|
|
valopt target "${CFG_HOST}" "GNUs ./configure syntax LLVM target triples"
|
|
|
|
valopt localstatedir "/var/lib" "local state directory"
|
|
valopt sysconfdir "/etc" "install system configuration files"
|
|
|
|
valopt datadir "${CFG_PREFIX}/share" "install data"
|
|
valopt infodir "${CFG_PREFIX}/share/info" "install additional info"
|
|
valopt mandir "${CFG_PREFIX}/share/man" "install man pages in PATH"
|
|
|
|
# On windows we just store the libraries in the bin directory because
|
|
# there's no rpath. This is where the build system itself puts libraries;
|
|
# --libdir is used to configure the installation directory.
|
|
# FIXME: Thise needs to parameterized over target triples. Do it in platform.mk
|
|
CFG_LIBDIR_RELATIVE=lib
|
|
if [ "$CFG_OSTYPE" = "pc-mingw32" ] || [ "$CFG_OSTYPE" = "w64-mingw32" ]
|
|
then
|
|
CFG_LIBDIR_RELATIVE=bin
|
|
fi
|
|
|
|
valopt libdir "${CFG_PREFIX}/${CFG_LIBDIR_RELATIVE}" "install libraries"
|
|
|
|
if [ $HELP -eq 1 ]
|
|
then
|
|
echo
|
|
exit 0
|
|
fi
|
|
|
|
# Validate Options
|
|
step_msg "validating $CFG_SELF args"
|
|
validate_opt
|
|
|
|
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_XELATEX xelatex
|
|
probe CFG_LUALATEX lualatex
|
|
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/')
|
|
|
|
MIN_PV_MAJOR="1"
|
|
MIN_PV_MINOR="9"
|
|
# these patterns are shell globs, *not* regexps
|
|
PV_MAJOR=${PV_MAJOR_MINOR% *}
|
|
PV_MINOR=${PV_MAJOR_MINOR#* }
|
|
if [ "$PV_MAJOR" -lt "$MIN_PV_MAJOR" ] || [ "$PV_MINOR" -lt "$MIN_PV_MINOR" ]
|
|
then
|
|
step_msg "pandoc $PV_MAJOR.$PV_MINOR is too old. Need at least $MIN_PV_MAJOR.$MIN_PV_MINOR. 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
|
|
|
|
BIN_SUF=
|
|
if [ "$CFG_OSTYPE" = "pc-mingw32" ] || [ "$CFG_OSTYPE" = "w64-mingw32" ]
|
|
then
|
|
BIN_SUF=.exe
|
|
fi
|
|
|
|
if [ ! -z "$CFG_ENABLE_LOCAL_RUST" ]
|
|
then
|
|
if [ ! -f ${CFG_LOCAL_RUST_ROOT}/bin/rustc${BIN_SUF} ]
|
|
then
|
|
err "no local rust to use"
|
|
else
|
|
LRV=`${CFG_LOCAL_RUST_ROOT}/bin/rustc${BIN_SUF} --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
|
|
|
|
# OS X 10.9, gcc is actually clang. This can cause some confusion in the build
|
|
# system, so if we find that gcc is clang, we should just use clang directly.
|
|
if [ $CFG_OSTYPE = apple-darwin -a -z "$CFG_ENABLE_CLANG" ]
|
|
then
|
|
CFG_OSX_GCC_VERSION=$("$CFG_GCC" --version 2>&1 | grep "Apple LLVM version")
|
|
if [ $? -eq 0 ]
|
|
then
|
|
step_msg "on OS X 10.9, forcing use of clang"
|
|
CFG_ENABLE_CLANG=1
|
|
putvar CFG_ENABLE_CLANG
|
|
else
|
|
if [ $("$CFG_GCC" --version 2>&1 | grep -c ' 4\.[0-6]') -ne 0 ]; then
|
|
step_msg "older GCC found, using clang instead"
|
|
CFG_ENABLE_CLANG=1
|
|
putvar CFG_ENABLE_CLANG
|
|
else
|
|
# on OS X, with xcode 5 and newer, certain developers may have
|
|
# cc, gcc and g++ point to a mixture of clang and gcc
|
|
# if so, this will create very strange build errors
|
|
# this last stanza is to detect some such problems and save the future rust
|
|
# contributor some time solving that issue.
|
|
# this detection could be generalized to other OSes aside from OS X
|
|
# but the issue seems most likely to happen on OS X
|
|
|
|
chk_cc () {
|
|
$1 --version 2> /dev/null | grep -q $2
|
|
}
|
|
# check that gcc, cc and g++ all point to the same compiler.
|
|
# note that for xcode 5, g++ points to clang, not clang++
|
|
if !((chk_cc gcc clang && chk_cc g++ clang) ||
|
|
(chk_cc gcc gcc &&( chk_cc g++ g++ || chk g++ gcc))) then
|
|
err "the gcc and g++ in your path point to different compilers.
|
|
Check which versions are in your path with cc --version and g++ --version.
|
|
To resolve this problem, either fix your PATH or run configure with --enable-clang"
|
|
fi
|
|
|
|
fi
|
|
fi
|
|
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.[2-5]*)
|
|
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* | 3.5* )
|
|
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_MANDIR=${CFG_MANDIR%/}
|
|
CFG_HOST="$(echo $CFG_HOST | tr ',' ' ')"
|
|
CFG_TARGET="$(echo $CFG_TARGET | tr ',' ' ')"
|
|
CFG_SUPPORTED_TARGET="$(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 $CFG_TARGET;
|
|
do
|
|
echo "$V_TEMP" | grep -qF $i || V_TEMP="$V_TEMP${V_TEMP:+ }$i"
|
|
done
|
|
CFG_TARGET=$V_TEMP
|
|
|
|
# check target-specific tool-chains
|
|
for i in $CFG_TARGET
|
|
do
|
|
L_CHECK=false
|
|
for j in $CFG_SUPPORTED_TARGET
|
|
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
|
|
;;
|
|
|
|
arm-apple-darwin)
|
|
if [ $CFG_OSTYPE != apple-darwin ]
|
|
then
|
|
err "The iOS target is only supported on Mac OS X"
|
|
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 dist
|
|
do
|
|
make_dir $i
|
|
done
|
|
|
|
for t in $CFG_HOST
|
|
do
|
|
make_dir $t/llvm
|
|
done
|
|
|
|
for t in $CFG_HOST
|
|
do
|
|
make_dir $t/rustllvm
|
|
done
|
|
|
|
for t in $CFG_TARGET
|
|
do
|
|
make_dir $t/rt
|
|
for s in 0 1 2 3
|
|
do
|
|
make_dir $t/rt/stage$s
|
|
make_dir $t/rt/libuv
|
|
make_dir $t/rt/libuv/src/ares
|
|
make_dir $t/rt/libuv/src/eio
|
|
make_dir $t/rt/libuv/src/ev
|
|
for i in \
|
|
isaac sync test \
|
|
arch/i386 arch/x86_64 arch/arm arch/mips \
|
|
sundown/src sundown/html
|
|
do
|
|
make_dir $t/rt/stage$s/$i
|
|
done
|
|
done
|
|
done
|
|
|
|
for h in $CFG_HOST
|
|
do
|
|
for t in $CFG_TARGET
|
|
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_RELATIVE
|
|
|
|
# host test dir
|
|
make_dir $h/stage$i/test
|
|
|
|
# target bin dir
|
|
make_dir $h/stage$i/$CFG_LIBDIR_RELATIVE/rustlib/$t/bin
|
|
|
|
# target lib dir
|
|
make_dir $h/stage$i/$CFG_LIBDIR_RELATIVE/rustlib/$t/lib
|
|
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-guide-ffi
|
|
make_dir $h/test/doc-guide-runtime
|
|
make_dir $h/test/doc-guide-macros
|
|
make_dir $h/test/doc-guide-lifetimes
|
|
make_dir $h/test/doc-guide-pointers
|
|
make_dir $h/test/doc-guide-container
|
|
make_dir $h/test/doc-guide-tasks
|
|
make_dir $h/test/doc-complement-cheatsheet
|
|
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
|
|
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"
|
|
# Try to have LLVM pull in as few dependencies as possible (#9397)
|
|
LLVM_OPTS="$LLVM_OPTS --disable-zlib --disable-libffi"
|
|
|
|
# Use win32 native thread/lock apis instead of pthread wrapper.
|
|
# (llvm's configure tries to find pthread first, so we have to disable it explicitly.)
|
|
# Also note that pthreads works badly on mingw-w64 systems: #8996
|
|
case "$CFG_BUILD" in
|
|
(*-mingw32)
|
|
LLVM_OPTS="$LLVM_OPTS --disable-pthreads"
|
|
;;
|
|
esac
|
|
|
|
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"
|
|
LLVM_OPTS="$LLVM_OPTS --enable-libcpp"
|
|
;;
|
|
("clang")
|
|
LLVM_CXX_32="clang++ -m32 -Qunused-arguments"
|
|
LLVM_CC_32="clang -m32 -Qunused-arguments"
|
|
|
|
LLVM_CXX_64="clang++ -Qunused-arguments"
|
|
LLVM_CC_64="clang -Qunused-arguments"
|
|
LLVM_OPTS="$LLVM_OPTS --enable-libcpp"
|
|
;;
|
|
("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
|
|
putvar CFG_HOST
|
|
putvar CFG_TARGET
|
|
putvar CFG_C_COMPILER
|
|
putvar CFG_LIBDIR
|
|
putvar CFG_LIBDIR_RELATIVE
|
|
putvar CFG_DISABLE_MANAGE_SUBMODULES
|
|
putvar CFG_ANDROID_CROSS_PATH
|
|
putvar CFG_MINGW32_CROSS_PATH
|
|
putvar CFG_MANDIR
|
|
putvar CFG_DISABLE_INJECT_STD_VERSION
|
|
|
|
# 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
|
|
|
|
# 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
|
|
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"
|
|
msg "run \`make help\`"
|
|
msg
|