build-arch

#!/bin/bash
#set -x
set -e

[ -e /etc/makepkg.conf ] && source /etc/makepkg.conf
MAKEFLAGS=${MAKEFLAGS:--j6}

# Basic configuration
GHCHOME=${GHCHOME:-/opt/ghc}
BASEDIR="$(dirname $0)"
cd "$BASEDIR"
BASEDIR="$(pwd)"

# Basic parameters
NDK_RELEASE=${NDK_RELEASE:-r9d}
NDK_MD5=c7c775ab3342965408d20fd18e71aa45
NDK_PLATFORM=${NDK_PLATFORM:-android-14}

if [ "x$1" == "x--x86" ] ; then
    NDK_TOOLCHAIN=${NDK_TOOLCHAIN:-x86-4.8}
    NDK_TARGET=${NDK_TARGET:-i686-linux-android}
    ARCH_OPTS=""
    GHC_TARGET=${GHC_TARGET:-x86-4.8}
elif [ "x$1" == "x--arm" ] ; then
    NDK_TOOLCHAIN=${NDK_TOOLCHAIN:-arm-linux-androideabi-4.8}
    NDK_TARGET=${NDK_TARGET:-arm-linux-androideabi}
    ARCH_OPTS="-fllvm"
    GHC_TARGET=${GHC_TARGET:-arm-unknown-linux-androideabi}
else
    echo Please select an architecture to build with --arm or --x86.
    exit 1
fi

NDK_DESC=$NDK_PLATFORM-$NDK_TOOLCHAIN
NDK="$GHCHOME/$NDK_PLATFORM/$NDK_TOOLCHAIN"
NDK_ADDON_SRC="$BASEDIR/build-$NDK_DESC"
NDK_ADDON_PREFIX="$NDK/sysroot/usr"

GHC_RELEASE=${GHC_RELEASE:-7.8.3}
GHC_STAGE0_MD5=4dd880afc51c6ba6126e26d17b6340d9
GHC_SRC_MD5=5e34b2a29564596c9ed83fb8667b47d4

GHC_STAGE0_SRC="$BASEDIR/ghc-$GHC_RELEASE"
GHC_STAGE0_PREFIX="$GHCHOME"
GHC_STAGE0="$GHC_STAGE0_PREFIX/bin/ghc"

GHC_PREFIX="$NDK"
GHC_SRC="$NDK_ADDON_SRC/ghc-$GHC_RELEASE"

NCURSES_RELEASE=5.9
NCURSES_MD5=8cb9c412e5f2d96bc6f459aa8c6282a1

GMP_RELEASE=6.0.0a
GMP_MD5=1e6da4e434553d2811437aa42c7f7c76

CONFIG_SUB_SRC=${CONFIG_SUB_SRC:-/usr/share/automake-1.14}

BUILD_GCC=gcc
BUILD_ARCH=$($BUILD_GCC -v 2>&1 | grep ^Target: | cut -f 2 -d ' ')

mkdir -p "$GHCHOME"
mkdir -p "$NDK_ADDON_SRC"
mkdir -p "${BASEDIR}/tarfiles"
TARDIR="${BASEDIR}/tarfiles"

function check_md5() {
    FILENAME="$1"
    MD5="$2"
    [ -e "${FILENAME}" ] || return 1;
    [ "$(md5sum "$FILENAME" | cut -f1 -d ' ')" == "$MD5" ]
}

function apply_patches() {
    pushd $2 > /dev/null
    for p in $(find "$BASEDIR/patches" -name "$1") ; do
        echo Applying patch $p in $(pwd)
        patch -p1 < "$p"
    done
    popd > /dev/null
}

# Download and configure the Android NDK toolchain
NDK_TAR_FILE=android-ndk-${NDK_RELEASE}-linux-x86_64.tar.bz2
NDK_TAR_PATH="${TARDIR}/${NDK_TAR_FILE}"
NDK_PATH="$BASEDIR/android-ndk-$NDK_RELEASE"
if ! [ -d "$NDK" ] ; then
    if ! [ -d "$NDK_PATH" ] ; then
        if ! check_md5 "$NDK_TAR_PATH" "$NDK_MD5" ; then
            echo Downloading the Android NDK $NDK_RELEASE
            curl -o "${TARDIR}/${NDK_TAR_FILE}"  http://dl.google.com/android/ndk/${NDK_TAR_FILE}
            check_md5 "$NDK_TAR_PATH" "$NDK_MD5"
        fi
        echo Unpacking the Android NDK $NDK_RELEASE
        tar xf "$NDK_TAR_PATH"
    fi
    echo Preparing the Android NDK toolchain in $NDK
    "$NDK_PATH/build/tools/make-standalone-toolchain.sh" --toolchain=$NDK_TOOLCHAIN --platform=$NDK_PLATFORM --install-dir="$NDK"

    #TMP hack, fake pthread library for ghc linker
    pushd "$NDK_ADDON_PREFIX/lib" > /dev/null
    ln -s libcharset.a libpthread.a
    popd > /dev/null
fi

# Add toolchain to path
export PATH="$NDK/bin":$PATH

# Unpack ncurses
NCURSES_TAR_FILE=ncurses-${NCURSES_RELEASE}.tar.gz
NCURSES_TAR_PATH="${TARDIR}/${NCURSES_TAR_FILE}"
NCURSES_SRC="$NDK_ADDON_SRC/ncurses-${NCURSES_RELEASE}"
if ! [ -d "$NCURSES_SRC" ] ; then
    if ! check_md5 "$NCURSES_TAR_PATH" "$NCURSES_MD5" ; then
        echo Downloading ncurses $NCURSES_RELEASE
        curl -o "${TARDIR}/${NCURSES_TAR_FILE}"  http://ftp.gnu.org/pub/gnu/ncurses/${NCURSES_TAR_FILE}
        check_md5 "$NCURSES_TAR_PATH" "$NCURSES_MD5"
    fi
    (cd $NDK_ADDON_SRC; tar xf "$TARDIR/$NCURSES_TAR_FILE")
fi

if ! [ -e "$CONFIG_SUB_SRC/config.sub" ] ; then
    CONFIG_SUB_SRC=${CONFIG_SUB_SRC:-$NCURSES_SRC}
fi

# Build and install iconv
ICONV_SRC="$NDK_ADDON_SRC/iconv"
if ! [ -e "$NDK_ADDON_PREFIX/lib/libiconv.a" ] ; then
    if ! [ -d "$ICONV_SRC" ] ; then
        git clone https://github.com/ironsteel/iconv-android.git $ICONV_SRC

        # Update config.sub and config.guess
        cp -v "$CONFIG_SUB_SRC/config.sub" "$ICONV_SRC/build-aux"
        cp -v "$CONFIG_SUB_SRC/config.guess" "$ICONV_SRC/build-aux"
        cp -v "$CONFIG_SUB_SRC/config.sub" "$ICONV_SRC/libcharset/build-aux"
        cp -v "$CONFIG_SUB_SRC/config.guess" "$ICONV_SRC/libcharset/build-aux"

        apply_patches 'iconv-*' $ICONV_SRC
    fi

    pushd $ICONV_SRC > /dev/null
    if ! [ -e "lib/.libs/libiconv.a" ] ; then
        ./configure --prefix="$NDK_ADDON_PREFIX" --host=$NDK_TARGET --build=$BUILD_ARCH --with-build-cc=$BUILD_GCC --enable-static --disable-shared
        make $MAKEFLAGS
    fi
    make install
    popd > /dev/null
fi

# Build and install ncurses
if ! [ -e "$NDK_ADDON_PREFIX/lib/libncurses.a" ] ; then
    pushd $NCURSES_SRC > /dev/null
    if ! [ -e "lib/libncurses.a" ] ; then
        ./configure --prefix="$NDK_ADDON_PREFIX" --host=$NDK_TARGET --build=$BUILD_ARCH --with-build-cc=$BUILD_GCC --enable-static --disable-shared --includedir="$NDK_ADDON_PREFIX/include" --without-manpages
        echo '#undef HAVE_LOCALE_H' >> "$NCURSES_SRC/include/ncurses_cfg.h"   # TMP hack
        make $MAKEFLAGS
    fi
    make install
    popd > /dev/null
fi

# Build and install gmp
GMP_TAR_FILE=gmp-${GMP_RELEASE}.tar.xz
GMP_TAR_PATH="${TARDIR}/${GMP_TAR_FILE}"
GMP_SRC="$NDK_ADDON_SRC/gmp-6.0.0"
if ! [ -d "$GMP_SRC" ] ; then
    if ! check_md5 "$GMP_TAR_PATH" "$GMP_MD5" ; then
        echo Downloading gmp $GMP_RELEASE
        curl -o "${TARDIR}/${GMP_TAR_FILE}"  https://gmplib.org/download/gmp/${GMP_TAR_FILE}
        check_md5 "$GMP_TAR_PATH" "$GMP_MD5"
    fi
    (cd $NDK_ADDON_SRC; tar xf "$TARDIR/$GMP_TAR_FILE")
fi
if ! [ -e "$NDK_ADDON_PREFIX/lib/libgmp.a" ] ; then
    pushd $GMP_SRC > /dev/null
    if ! [ -e ".libs/libgmp.a" ] ; then
        ./configure --prefix="$NDK_ADDON_PREFIX" --host=$NDK_TARGET --build=$BUILD_ARCH --with-build-cc=$BUILD_GCC --enable-static --disable-shared
        make $MAKEFLAGS
    fi
    make install
    popd > /dev/null
fi

GHC_STAGE0_TAR_FILE=ghc-${GHC_RELEASE}-x86_64-unknown-linux-deb7.tar.xz
GHC_STAGE0_TAR_PATH="${TARDIR}/${GHC_STAGE0_TAR_FILE}"
if ! [ -e "$GHC_STAGE0" ] ; then
    if ! check_md5 "$GHC_STAGE0_TAR_PATH" "$GHC_STAGE0_MD5" ; then
        echo Downloading the GHC $GHC_RELEASE binary release
        curl -o "${TARDIR}/${GHC_STAGE0_TAR_FILE}"  http://www.haskell.org/ghc/dist/$GHC_RELEASE/$GHC_STAGE0_TAR_FILE
        check_md5 "$GHC_STAGE0_TAR_PATH" "$GHC_STAGE0_MD5"
    fi
    echo Unpacking the GHC $GHC_RELEASE binary release
    tar xf "$GHC_STAGE0_TAR_PATH"
    pushd "$GHC_STAGE0_SRC" > /dev/null
    ./configure --prefix="$GHC_STAGE0_PREFIX"
    make $MAKEFLAGS install
    popd > /dev/null
fi

GHC_SRC_TAR_FILE=ghc-${GHC_RELEASE}-src.tar.xz
GHC_SRC_TAR_PATH="${TARDIR}/${GHC_SRC_TAR_FILE}"
if ! [ -d "$GHC_SRC" ] ; then
    if ! check_md5 "$GHC_SRC_TAR_PATH" "$GHC_SRC_MD5" ; then
        echo Downloading the GHC $GHC_RELEASE source release
        curl -o "${TARDIR}/${GHC_SRC_TAR_FILE}"  http://www.haskell.org/ghc/dist/$GHC_RELEASE/$GHC_SRC_TAR_FILE
        check_md5 "$GHC_SRC_TAR_PATH" "$GHC_SRC_MD5"
    fi
    pushd "$NDK_ADDON_SRC" > /dev/null
    echo Unpacking the GHC $GHC_RELEASE source release
    tar xf "$GHC_SRC_TAR_PATH"
    popd > /dev/null
    apply_patches 'ghc-*' "$GHC_SRC"
    pushd "$GHC_SRC" > /dev/null

    # Setup build.mk
    cat > mk/build.mk <<EOF
Stage1Only = YES
DYNAMIC_GHC_PROGRAMS = NO
SRC_HC_OPTS     = -O -H64m
GhcStage1HcOpts = -O2 -fasm
GhcStage2HcOpts = -O2 -fasm $ARCH_OPTS
GhcHcOpts       = -Rghc-timing
GhcLibHcOpts    = -O2
GhcLibWays      = v
HADDOCK_DOCS       = NO
BUILD_DOCBOOK_HTML = NO
BUILD_DOCBOOK_PS   = NO
BUILD_DOCBOOK_PDF  = NO
EOF

    # Update config.sub and config.guess
    for x in $(find . -name "config.sub") ; do
        dir=$(dirname $x)
        cp -v "$CONFIG_SUB_SRC/config.sub" "$dir"
        cp -v "$CONFIG_SUB_SRC/config.guess" "$dir"
    done

    # Apply library patches
    apply_patches "hsc2hs-*" "$GHC_SRC/utils/hsc2hs"
    apply_patches "haskeline-*" "$GHC_SRC/libraries/haskeline"
    apply_patches "unix-*" "$GHC_SRC/libraries/unix"
    apply_patches "base-*" "$GHC_SRC/libraries/base"

    # Configure
    ./configure --prefix="$GHC_PREFIX" --target=$NDK_TARGET --with-ghc=$GHC_STAGE0 --with-gcc=$NDK/bin/$NDK_TARGET-gcc
    popd > /dev/null
fi

GHC_STAGE1=$NDK/bin/$GHC_TARGET-ghc
if ! [ -e "$GHC_STAGE1" ] ; then
    pushd "$GHC_SRC" > /dev/null

    function check_install_gmp_constants() {
        GMPDCHDR="libraries/integer-gmp/mkGmpDerivedConstants/dist/GmpDerivedConstants.h"
        if ! [ -e  "$GMPDCHDR" ] ; then
            if [ -e "$BASEDIR/patches/gmp-$NDK_DESC-GmpDerivedConstants.h" ] ; then
                cp -v "$BASEDIR/patches/gmp-$NDK_DESC-GmpDerivedConstants.h" "$GMPDCHDR"
            else
                echo \#\#\# Execute the following commands to generate a GmpDerivedConstants.h for your target, then run build again:
                echo \#\#\# adb push ghc-$NDK_DESC/libraries/integer-gmp/cbits/mkGmpDerivedConstants /data/local
                echo \#\#\# adb shell /data/local/mkGmpDerivedConstants \> $BASEDIR/patches/gmp-$NDK_DESC-GmpDerivedConstants.h
                echo \#\#\# adb shell rm /data/local/mkGmpDerivedConstants
                exit 1
            fi
        fi
    }

    make $MAKEFLAGS || true # TMP hack, see http://hackage.haskell.org/trac/ghc/ticket/7490
    make $MAKEFLAGS || true # TMP hack, target mkGmpDerivedConstants fails on build host
    check_install_gmp_constants
    make $MAKEFLAGS || true # TMP hack, tries to execut inplace stage2
    make $MAKEFLAGS || true # TMP hack, one more for luck
    make install
    popd > /dev/null
fi

# Write hsc2hs wrapper
HSC2HS_TARGET=$(ls $GHC_PREFIX/bin/$GHC_TARGET-hsc2hs)
echo \#/bin/bash > $HSC2HS_TARGET
echo 'exec /usr/bin/hsc2hs --cross-compile "$@" --define=linux_android_HOST_OS=1' >> $HSC2HS_TARGET
chmod +x $HSC2HS_TARGET

GHC_STAGE0_CABAL="$GHC_STAGE0_PREFIX/bin/cabal"
if ! [ -e "$GHC_STAGE0_CABAL" ] ; then
    # install a cabal that supports cross compilation
    CABAL_SRC="$NDK_ADDON_SRC/cabal"
    if ! [ -d "$CABAL_SRC" ] ; then
        git clone https://github.com/haskell/cabal.git $CABAL_SRC
    fi

    pushd $CABAL_SRC/Cabal > /dev/null
    $GHC_STAGE0 -threaded --make Setup
    ./Setup configure \
        --prefix=$GHC_STAGE0_PREFIX \
        --bindir=$GHC_STAGE0_PREFIX/bin/ \
        --with-compiler=$GHC_STAGE0 \
        --with-ghc=$GHC_STAGE0 \
        --with-ghc-pkg=$GHC_STAGE0_PREFIX/bin/ghc-pkg \
        --with-hsc2hs=$GHC_STAGE0_PREFIX/bin/hsc2hs \
        --package-db=$GHC_STAGE0_PREFIX/lib/ghc-$GHC_RELEASE/package.conf.d
    ./Setup build
    ./Setup install
    popd > /dev/null

    pushd $CABAL_SRC/cabal-install > /dev/null
    (
        set -e
        GHC=$GHC_STAGE0
        GHC_PKG=$GHC_STAGE0_PREFIX/bin/ghc-pkg
        HADDOCK=$GHC_STAGE0_PREFIX/bin/haddock
        PREFIX=$GHC_STAGE0_PREFIX
        . ./bootstrap.sh --global
    )
    popd > /dev/null
    $GHC_STAGE0_CABAL update
fi

CABAL_WRAPPER="$GHC_PREFIX/bin/$GHC_TARGET-cabal"
if ! [ -e "$CABAL_WRAPPER" ] ; then
    # Write cabal wrapper
    echo \#/bin/bash > "$CABAL_WRAPPER"
    echo NDK=$GHC_PREFIX >> "$CABAL_WRAPPER"
    echo NDK_TARGET=$NDK_TARGET >> "$CABAL_WRAPPER"
    echo GHC_TARGET=$GHC_TARGET >> "$CABAL_WRAPPER"
    echo GHC_RELEASE=$GHC_RELEASE >> "$CABAL_WRAPPER"
    echo BIN_CABAL=$GHC_STAGE0_PREFIX/bin/cabal >> "$CABAL_WRAPPER"
    cat "$BASEDIR/patches/cabal-wrapper" >> "$CABAL_WRAPPER"
    chmod +x "$CABAL_WRAPPER"
fi

# Add target bindir links
function maybe_link() {
    if [ -e "$1" -a ! -e "$2" ] ; then ln -sf "$1" "$2" ; fi
}
function bindir_link() {
    maybe_link $GHC_PREFIX/bin/$GHC_TARGET-$1 $GHC_PREFIX/$NDK_TARGET/bin/$1
    maybe_link $GHC_PREFIX/bin/$GHC_TARGET-$1 $GHC_PREFIX/bin/$NDK_TARGET-$1
}
bindir_link ghc
bindir_link ghc-pkg
bindir_link hp2ps
bindir_link hsc2hs
bindir_link cabal

for f in $(ls $GHC_PREFIX/bin/$GHC_TARGET-*) ; do
    maybe_link $f $GHC_STAGE0_PREFIX/bin/$(basename $f)
done
for f in $(ls $NDK/bin/$NDK_TARGET-*) ; do
    maybe_link $f $GHC_STAGE0_PREFIX/bin/$(basename $f)
done