libretro/Lakka-LibreELEC
1
0
Fork 0
mirror of https://github.com/libretro/Lakka-LibreELEC.git synced 2024-11-23 08:20:00 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
Lakka-v5.x
Lakka-LibreELEC/scripts/build
Matthias Reichl f5f9a9e1cc scripts/build: properly honor strip build flag 
Package building honor's the strip flag so we can prevent executables
from being stripped.

But copying files to INSTALL ignored that flag which meant the flag
had practically no effect.

Fix this by using the same logic as we do in the meson strip handling in
line 170 and in config/functions.

Also add the missing quotes in scripts/build to align it with config/functions

Signed-off-by: Matthias Reichl <hias@horus.com>
2023-03-30 17:19:48 +02:00

575 lines
21 KiB
Bash
Executable File
Raw Permalink Blame History

#!/bin/bash
# SPDX-License-Identifier: GPL-2.0-or-later
# Copyright (C) 2009-2016 Stephan Raue (stephan@openelec.tv)
# Copyright (C) 2018-present Team LibreELEC (https://libreelec.tv)
. config/options "${1}"
record_timestamp BUILD_BEGIN
if [ -z "${1}" ]; then
die "usage: ${0} package_name[:<host|target|init|bootstrap>] [parent_pkg]"
fi
if [ "${1}" = "--all" ]; then
if [ -n "${2}" ]; then
for build_dir in $(ls -1d ${BUILD_ROOT}/${BUILD_BASE}.*); do
load_build_config ${build_dir} && ${SCRIPTS}/build "${2}"
done
fi
exit 0
fi
if [ -z "${PKG_NAME}" ]; then
die "$(print_color CLR_ERROR "${1}: no package.mk file found")"
fi
if [ -n "${PKG_ARCH}" ]; then
listcontains "${PKG_ARCH}" "!${TARGET_ARCH}" && exit 0
listcontains "${PKG_ARCH}" "${TARGET_ARCH}" || listcontains "${PKG_ARCH}" "any" || exit 0
fi
if [ "${1//:/}" != "${1}" ]; then
TARGET="${1#*:}"
else
TARGET=
fi
TARGET="${TARGET:-target}"
PARENT_PKG="${2:-${PKG_NAME}:${TARGET}}"
pkg_lock "${PKG_NAME}:${TARGET}" "build" "${PARENT_PKG}"
mkdir -p ${STAMPS}/${PKG_NAME}
STAMP=${STAMPS}/${PKG_NAME}/build_${TARGET}
if [ -f ${STAMP} ]; then
. ${STAMP}
PKG_DEEPHASH=$(calculate_stamp)
if [ "${PKG_DEEPHASH}" = "${STAMP_PKG_DEEPHASH}" -a "${BUILD_WITH_DEBUG}" = "${STAMP_BUILD_WITH_DEBUG}" ]; then
# stamp matched: already built, do nothing
pkg_lock_status "UNLOCK" "${PKG_NAME}:${TARGET}" "build" "already built"
exit 0
fi
rm -f ${STAMP}
fi
${SCRIPTS}/unpack "${PKG_NAME}" "${PARENT_PKG}"
# build dependencies, only when PKG_DEPENDS_? is filled
unset _pkg_depends
case "${TARGET}" in
"target") _pkg_depends="${PKG_DEPENDS_TARGET}";;
"host") _pkg_depends="${PKG_DEPENDS_HOST}";;
"init") _pkg_depends="${PKG_DEPENDS_INIT}";;
"bootstrap") _pkg_depends="${PKG_DEPENDS_BOOTSTRAP}";;
esac
if is_sequential_build; then
for p in ${_pkg_depends}; do
${SCRIPTS}/build "${p}" "${PARENT_PKG}"
done
fi
# virtual packages are not built as they only contain dependencies, so dont go further here
if [ "${PKG_SECTION}" = "virtual" ]; then
PKG_DEEPHASH=$(calculate_stamp)
for i in PKG_NAME PKG_DEEPHASH BUILD_WITH_DEBUG; do
echo "STAMP_${i}=\"${!i}\"" >> ${STAMP}
done
pkg_lock_status "UNLOCK" "${PKG_NAME}:${TARGET}" "build" "built"
exit 0
fi
# build this package
if [ "${BUILD_WITH_DEBUG}" = "yes" ]; then
build_msg "CLR_BUILD" "BUILD" "${PKG_NAME} $(print_color "CLR_TARGET" "(${TARGET})") [DEBUG]" "indent"
else
build_msg "CLR_BUILD" "BUILD" "${PKG_NAME} $(print_color "CLR_TARGET" "(${TARGET})")" "indent"
fi
# setup configure scripts
PKG_CONFIGURE_SCRIPT="${PKG_CONFIGURE_SCRIPT:-${PKG_BUILD}/configure}"
PKG_CMAKE_SCRIPT="${PKG_CMAKE_SCRIPT:-${PKG_BUILD}/CMakeLists.txt}"
PKG_MESON_SCRIPT="${PKG_MESON_SCRIPT:-${PKG_BUILD}/meson.build}"
# auto detect toolchain
_auto_toolchain=""
if [ -z "${PKG_TOOLCHAIN}" -o "${PKG_TOOLCHAIN}" = "auto" ]; then
if [ -f "${PKG_MESON_SCRIPT}" ]; then
PKG_TOOLCHAIN="meson"
elif [ -f "${PKG_CMAKE_SCRIPT}" ]; then
PKG_TOOLCHAIN="cmake"
elif [ -f "${PKG_CONFIGURE_SCRIPT}" ]; then
PKG_TOOLCHAIN="configure"
elif [ -f "${PKG_BUILD}/Makefile" ]; then
PKG_TOOLCHAIN="make"
else
die "Not possible to detect toolchain automatically. Add PKG_TOOLCHAIN= to package.mk"
fi
_auto_toolchain=" (auto-detect)"
fi
if ! listcontains "meson cmake cmake-make configure ninja make autotools manual" "${PKG_TOOLCHAIN}"; then
die "$(print_color "CLR_ERROR" "ERROR:") unknown toolchain ${PKG_TOOLCHAIN}"
fi
build_msg "CLR_TOOLCHAIN" "TOOLCHAIN" "${PKG_TOOLCHAIN}${_auto_toolchain}"
# check wrong toolchain configuration
check_toolchain_config ${TARGET} ${PKG_TOOLCHAIN}
# setup toolchain
setup_toolchain ${TARGET} ${PKG_TOOLCHAIN}
# configure install directory
[ -n "${PKG_INSTALL}" ] && INSTALL="${PKG_INSTALL}" || unset INSTALL
# remove previous install files
if [ -n "${INSTALL}" -a -d "${INSTALL}" ]; then
rm -rf "${INSTALL}"
fi
# configure debug build defaults
if [ "${BUILD_WITH_DEBUG}" = "yes" ]; then
CMAKE_BUILD_TYPE="Debug"
MESON_BUILD_TYPE="debug"
else
CMAKE_BUILD_TYPE="MinSizeRel"
MESON_BUILD_TYPE="plain"
fi
CMAKE_GENERATOR_NINJA="-GNinja \
-DCMAKE_EXPORT_COMPILE_COMMANDS=ON"
# configure TARGET build defaults
TARGET_CONFIGURE_OPTS="--host=${TARGET_NAME} \
--build=${HOST_NAME} \
--prefix=/usr \
--bindir=/usr/bin \
--sbindir=/usr/sbin \
--sysconfdir=/etc \
--libdir=/usr/lib \
--libexecdir=/usr/lib \
--localstatedir=/var \
--disable-static \
--enable-shared"
TARGET_CMAKE_OPTS="-DCMAKE_TOOLCHAIN_FILE=${CMAKE_CONF} \
-DCMAKE_INSTALL_PREFIX=/usr \
-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
TARGET_MESON_OPTS="--prefix=/usr \
--bindir=/usr/bin \
--sbindir=/usr/sbin \
--sysconfdir=/etc \
--libdir=/usr/lib \
--libexecdir=/usr/lib \
--localstatedir=/var \
--buildtype=${MESON_BUILD_TYPE}"
if [ "${BUILD_WITH_DEBUG}" != "yes" ] && flag_enabled "strip" "yes"; then
TARGET_MESON_OPTS+=" -Dstrip=true"
fi
# configure HOST build defaults
HOST_CONFIGURE_OPTS="--host=${HOST_NAME} \
--build=${HOST_NAME} \
--prefix=${TOOLCHAIN} \
--bindir=${TOOLCHAIN}/bin \
--sbindir=${TOOLCHAIN}/sbin \
--sysconfdir=${TOOLCHAIN}/etc \
--libexecdir=${TOOLCHAIN}/lib \
--localstatedir=${TOOLCHAIN}/var \
--disable-static \
--enable-shared"
HOST_CMAKE_OPTS="${CMAKE_GENERATOR} \
-DCMAKE_TOOLCHAIN_FILE=${CMAKE_CONF} \
-DCMAKE_INSTALL_PREFIX=${TOOLCHAIN} \
-DCMAKE_BUILD_TYPE=Release"
HOST_MESON_OPTS="--prefix=${TOOLCHAIN} \
--bindir=${TOOLCHAIN}/bin \
--sbindir=${TOOLCHAIN}/sbin \
--sysconfdir=${TOOLCHAIN}/etc \
--libdir=${TOOLCHAIN}/lib \
--libexecdir=${TOOLCHAIN}/lib \
--localstatedir=${TOOLCHAIN}/var \
--buildtype=plain"
# configure INIT build defaults
INIT_CONFIGURE_OPTS="${TARGET_CONFIGURE_OPTS}"
INIT_CMAKE_OPTS="${TARGET_CMAKE_OPTS}"
INIT_MESON_OPTS="${TARGET_MESON_OPTS}"
# configure BOOTSTRAP build defaults
BOOTSTRAP_CONFIGURE_OPTS="${HOST_CONFIGURE_OPTS}"
BOOTSTRAP_CMAKE_OPTS="${HOST_CMAKE_OPTS}"
BOOTSTRAP_MESON_OPTS="${HOST_MESON_OPTS}"
record_timestamp BUILD_START
# make autoreconf
if [ "${PKG_TOOLCHAIN}" = "autotools" ]; then
${SCRIPTS}/autoreconf "${PKG_NAME}" "${PARENT_PKG}" $(dirname "${PKG_CONFIGURE_SCRIPT}")
fi
pkg_lock_status "ACTIVE" "${PKG_NAME}:${TARGET}" "build"
# include build template and build
pkg_call_exists_opt pre_build_${TARGET} && pkg_call
# ensure ${PKG_BUILD} is there. (installer? PKG_URL="")
mkdir -p "${PKG_BUILD}"
cd "${PKG_BUILD}"
if [ -f "${PKG_CONFIGURE_SCRIPT}" -o -f "${PKG_CMAKE_SCRIPT}" -o -f "${PKG_MESON_SCRIPT}" ]; then
case "${TARGET}" in
"target") PKG_REAL_BUILD="${PKG_BUILD}/.${TARGET_NAME}" ;;
"host") PKG_REAL_BUILD="${PKG_BUILD}/.${HOST_NAME}" ;;
"init") PKG_REAL_BUILD="${PKG_BUILD}/.${TARGET_NAME}-${TARGET}" ;;
"bootstrap") PKG_REAL_BUILD="${PKG_BUILD}/.${HOST_NAME}-${TARGET}" ;;
esac
mkdir -p "${PKG_REAL_BUILD}"
cd "${PKG_REAL_BUILD}"
MESON_CONF="${PKG_REAL_BUILD}/meson.conf"
fi
# create wrapper scripts in build dir and use them for CC/CXX when
# building for host and local-cc build flag is set
if [ "${TARGET}" = "host" ] && flag_enabled "local-cc" "no"; then
cat > libreelec-local-cc << EOF
#!/bin/sh
exec ${CC} "\$@"
EOF
chmod +x libreelec-local-cc
export CC=$(pwd)/libreelec-local-cc
cat > libreelec-local-cxx << EOF
#!/bin/sh
exec ${CXX} "\$@"
EOF
chmod +x libreelec-local-cxx
export CXX=$(pwd)/libreelec-local-cxx
fi
# configure
if [ -n "${PKG_DEPENDS_CONFIG}" -a -n "${PKG_INSTALL}" ]; then
for pkg in ${PKG_DEPENDS_CONFIG}; do
for dir in "$(get_install_dir ${pkg})"/{usr/local/,usr/,}{lib/,share/}pkgconfig; do
if [ -d "${dir}" ]; then
build_msg "CLR_TOOLCHAIN" "PKG_CONFIG_PATH" "${dir}"
[ -n "${PKG_CONFIG_PATH}" ] && PKG_CONFIG_PATH+=":"
PKG_CONFIG_PATH+="${dir}"
fi
done
done
export PKG_CONFIG_PATH
fi
record_timestamp BUILD_CONFIGURE
pkg_call_exists_opt pre_configure && pkg_call
pkg_call_exists_opt pre_configure_${TARGET} && pkg_call
if pkg_call_exists configure_${TARGET}; then
pkg_call
else
case "${PKG_TOOLCHAIN}:${TARGET}" in
# meson builds
"meson:target")
create_meson_conf_target ${TARGET} ${MESON_CONF}
echo "Executing (target): meson setup ${TARGET_MESON_OPTS} --cross-file=${MESON_CONF} ${PKG_MESON_OPTS_TARGET} ${PKG_MESON_SCRIPT%/*}" | tr -s " "
CC="${HOST_CC}" CXX="${HOST_CXX}" meson setup ${TARGET_MESON_OPTS} --cross-file=${MESON_CONF} ${PKG_MESON_OPTS_TARGET} ${PKG_MESON_SCRIPT%/*}
;;
"meson:host")
create_meson_conf_host ${TARGET} ${MESON_CONF}
echo "Executing (host): meson setup ${HOST_MESON_OPTS} --native-file=${MESON_CONF} ${PKG_MESON_OPTS_HOST} ${PKG_MESON_SCRIPT%/*}" | tr -s " "
meson setup ${HOST_MESON_OPTS} --native-file=${MESON_CONF} ${PKG_MESON_OPTS_HOST} ${PKG_MESON_SCRIPT%/*}
;;
"meson:init")
create_meson_conf_target ${TARGET} ${MESON_CONF}
echo "Executing (init): meson setup ${INIT_MESON_OPTS} --cross-file=${MESON_CONF} ${PKG_MESON_OPTS_INIT} ${PKG_MESON_SCRIPT%/*}" | tr -s " "
meson setup ${INIT_MESON_OPTS} --cross-file=${MESON_CONF} ${PKG_MESON_OPTS_INIT} ${PKG_MESON_SCRIPT%/*}
;;
"meson:bootstrap")
create_meson_conf_host ${TARGET} ${MESON_CONF}
echo "Executing (bootstrap): meson setup ${BOOTSTRAP_MESON_OPTS} ----native-file=${MESON_CONF} ${PKG_MESON_OPTS_BOOTSTRAP} ${PKG_MESON_SCRIPT%/*}" | tr -s " "
meson setup ${BOOTSTRAP_MESON_OPTS} --native-file=${MESON_CONF} ${PKG_MESON_OPTS_BOOTSTRAP} ${PKG_MESON_SCRIPT%/*}
;;
# cmake builds with ninja
"cmake:target")
echo "Executing (target): cmake ${CMAKE_GENERATOR_NINJA} ${TARGET_CMAKE_OPTS} ${PKG_CMAKE_OPTS_TARGET} ${PKG_CMAKE_SCRIPT%/*}" | tr -s " "
cmake ${CMAKE_GENERATOR_NINJA} ${TARGET_CMAKE_OPTS} ${PKG_CMAKE_OPTS_TARGET} ${PKG_CMAKE_SCRIPT%/*}
;;
"cmake:host")
echo "Executing (host): cmake ${CMAKE_GENERATOR_NINJA} ${HOST_CMAKE_OPTS} ${PKG_CMAKE_OPTS_HOST} ${PKG_CMAKE_SCRIPT%/*}" | tr -s " "
cmake ${CMAKE_GENERATOR_NINJA} ${HOST_CMAKE_OPTS} ${PKG_CMAKE_OPTS_HOST} ${PKG_CMAKE_SCRIPT%/*}
;;
"cmake:init")
echo "Executing (init): cmake ${CMAKE_GENERATOR_NINJA} ${INIT_CMAKE_OPTS} ${PKG_CMAKE_OPTS_INIT} ${PKG_CMAKE_SCRIPT%/*}" | tr -s " "
cmake ${CMAKE_GENERATOR_NINJA} ${INIT_CMAKE_OPTS} ${PKG_CMAKE_OPTS_INIT} ${PKG_CMAKE_SCRIPT%/*}
;;
"cmake:bootstrap")
echo "Executing (bootstrap): cmake ${CMAKE_GENERATOR_NINJA} ${BOOTSTRAP_CMAKE_OPTS} ${PKG_CMAKE_OPTS_BOOTSTRAP} ${PKG_CMAKE_SCRIPT%/*}" | tr -s " "
cmake ${CMAKE_GENERATOR_NINJA} ${BOOTSTRAP_CMAKE_OPTS} ${PKG_CMAKE_OPTS_BOOTSTRAP} ${PKG_CMAKE_SCRIPT%/*}
;;
# cmake builds with make
"cmake-make:target")
echo "Executing (target): cmake ${TARGET_CMAKE_OPTS} ${PKG_CMAKE_OPTS_TARGET} ${PKG_CMAKE_SCRIPT%/*}" | tr -s " "
cmake ${TARGET_CMAKE_OPTS} ${PKG_CMAKE_OPTS_TARGET} ${PKG_CMAKE_SCRIPT%/*}
;;
"cmake-make:host")
echo "Executing (host): cmake ${HOST_CMAKE_OPTS} ${PKG_CMAKE_OPTS_HOST} ${PKG_CMAKE_SCRIPT%/*}" | tr -s " "
cmake ${HOST_CMAKE_OPTS} ${PKG_CMAKE_OPTS_HOST} ${PKG_CMAKE_SCRIPT%/*}
;;
"cmake-make:init")
echo "Executing (init): cmake ${INIT_CMAKE_OPTS} ${PKG_CMAKE_OPTS_INIT} ${PKG_CMAKE_SCRIPT%/*}" | tr -s " "
cmake ${INIT_CMAKE_OPTS} ${PKG_CMAKE_OPTS_INIT} ${PKG_CMAKE_SCRIPT%/*}
;;
"cmake-make:bootstrap")
echo "Executing (bootstrap): cmake ${BOOTSTRAP_CMAKE_OPTS} ${PKG_CMAKE_OPTS_BOOTSTRAP} ${PKG_CMAKE_SCRIPT%/*}" | tr -s " "
cmake ${BOOTSTRAP_CMAKE_OPTS} ${PKG_CMAKE_OPTS_BOOTSTRAP} ${PKG_CMAKE_SCRIPT%/*}
;;
# configure builds
"configure:target"|"autotools:target")
echo "Executing (target): ${PKG_CONFIGURE_SCRIPT} ${TARGET_CONFIGURE_OPTS} ${PKG_CONFIGURE_OPTS_TARGET}" | tr -s " "
${PKG_CONFIGURE_SCRIPT} ${TARGET_CONFIGURE_OPTS} ${PKG_CONFIGURE_OPTS_TARGET}
;;
"configure:host"|"autotools:host")
echo "Executing (host): ${PKG_CONFIGURE_SCRIPT} ${HOST_CONFIGURE_OPTS} ${PKG_CONFIGURE_OPTS_HOST}" | tr -s " "
${PKG_CONFIGURE_SCRIPT} ${HOST_CONFIGURE_OPTS} ${PKG_CONFIGURE_OPTS_HOST}
;;
"configure:init"|"autotools:init")
echo "Executing (init): ${PKG_CONFIGURE_SCRIPT} ${INIT_CONFIGURE_OPTS} ${PKG_CONFIGURE_OPTS_INIT}" | tr -s " "
${PKG_CONFIGURE_SCRIPT} ${INIT_CONFIGURE_OPTS} ${PKG_CONFIGURE_OPTS_INIT}
;;
"configure:bootstrap"|"autotools:bootstrap")
echo "Executing (bootstrap): ${PKG_CONFIGURE_SCRIPT} ${BOOTSTRAP_CONFIGURE_OPTS} ${PKG_CONFIGURE_OPTS_BOOTSTRAP}" | tr -s " "
${PKG_CONFIGURE_SCRIPT} ${BOOTSTRAP_CONFIGURE_OPTS} ${PKG_CONFIGURE_OPTS_BOOTSTRAP}
;;
esac
fi
pkg_call_exists_opt post_configure_${TARGET} && pkg_call
record_timestamp BUILD_MAKE
# make
pkg_call_exists_opt pre_make_${TARGET} && pkg_call
if pkg_call_exists make_${TARGET}; then
pkg_call
else
case "${PKG_TOOLCHAIN}:${TARGET}" in
# ninja based builds
"meson:target"|"cmake:target"|"ninja:target")
echo "Executing (target): ninja ${PKG_MAKE_OPTS_TARGET}" | tr -s " "
ninja ${NINJA_OPTS} ${PKG_MAKE_OPTS_TARGET}
;;
"meson:host"|"cmake:host"|"ninja:host")
echo "Executing (host): ninja ${PKG_MAKE_OPTS_HOST}" | tr -s " "
ninja ${NINJA_OPTS} ${PKG_MAKE_OPTS_HOST}
;;
"meson:init"|"cmake:init"|"ninja:init")
echo "Executing (init): ninja ${PKG_MAKE_OPTS_INIT}" | tr -s " "
ninja ${NINJA_OPTS} ${PKG_MAKE_OPTS_INIT}
;;
"meson:bootstrap"|"cmake:bootstrap"|"ninja:bootstrap")
echo "Executing (bootstrap): ninja ${PKG_MAKE_OPTS_BOOTSTRAP}" | tr -s " "
ninja ${NINJA_OPTS} ${PKG_MAKE_OPTS_BOOTSTRAP}
;;
# make based builds
"configure:target"|"cmake-make:target"|"autotools:target"|"make:target")
echo "Executing (target): make ${PKG_MAKE_OPTS_TARGET}" | tr -s " "
make ${PKG_MAKE_OPTS_TARGET}
;;
"configure:host"|"cmake-make:host"|"autotools:host"|"make:host")
echo "Executing (host): make ${PKG_MAKE_OPTS_HOST}" | tr -s " "
make ${PKG_MAKE_OPTS_HOST}
;;
"configure:init"|"cmake-make:init"|"autotools:init"|"make:init")
echo "Executing (init): make ${PKG_MAKE_OPTS_INIT}" | tr -s " "
make ${PKG_MAKE_OPTS_INIT}
;;
"configure:bootstrap"|"cmake-make:bootstrap"|"autotools:bootstrap"|"make:bootstrap")
echo "Executing (bootstrap): make ${PKG_MAKE_OPTS_BOOTSTRAP}" | tr -s " "
make ${PKG_MAKE_OPTS_BOOTSTRAP}
;;
esac
fi
pkg_call_exists_opt post_make_${TARGET} && pkg_call
# Hack around directly writing/modifying the content of a shared sysroot
# by temporarily installing new files to a package specific sysroot
export PKG_ORIG_SYSROOT_PREFIX="${SYSROOT_PREFIX}"
export SYSROOT_PREFIX="${BUILD}/.sysroot/${PKG_NAME}.${TARGET}"
rm -rf "${SYSROOT_PREFIX}"
# Create common sysroot directories as some packages expect them to exist.
# TODO: Fix those packages so we don't need to pre-create directories.
for d in /usr/lib /usr/include /usr/bin /usr/lib/pkgconfig; do
mkdir -p "${SYSROOT_PREFIX}${d}"
done
record_timestamp BUILD_MAKEINSTALL
# make install
pkg_call_exists_opt pre_makeinstall_${TARGET} && pkg_call
if pkg_call_exists makeinstall_${TARGET}; then
pkg_call
else
flag_enabled "sysroot" "yes" && INSTALL_TO_SYSROOT="yes" || INSTALL_TO_SYSROOT="no"
case "${PKG_TOOLCHAIN}:${TARGET}" in
# ninja based builds
"meson:target"|"cmake:target")
[ "${INSTALL_TO_SYSROOT}" = "yes" ] && \
DESTDIR=${SYSROOT_PREFIX} ninja install ${PKG_MAKEINSTALL_OPTS_TARGET}
DESTDIR=${INSTALL} ninja install ${PKG_MAKEINSTALL_OPTS_TARGET}
;;
"meson:host"|"cmake:host")
ninja install ${PKG_MAKEINSTALL_OPTS_HOST}
;;
"meson:init"|"cmake:init")
DESTDIR=${INSTALL} ninja install ${PKG_MAKEINSTALL_OPTS_INIT}
;;
"meson:bootstrap"|"cmake:bootstrap")
ninja install ${PKG_MAKEINSTALL_OPTS_BOOTSTRAP}
;;
# make based builds
"configure:target"|"cmake-make:target"|"autotools:target"|"make:target")
[ "${INSTALL_TO_SYSROOT}" = "yes" ] && \
make install DESTDIR=${SYSROOT_PREFIX} -j1 ${PKG_MAKEINSTALL_OPTS_TARGET}
make install DESTDIR=${INSTALL} ${PKG_MAKEINSTALL_OPTS_TARGET}
;;
"configure:host"|"cmake-make:host"|"autotools:host"|"make:host")
make install ${PKG_MAKEINSTALL_OPTS_HOST}
;;
"configure:init"|"cmake-make:init"|"autotools:init"|"make:init")
make install DESTDIR=${INSTALL} ${PKG_MAKEINSTALL_OPTS_INIT}
;;
"configure:bootstrap"|"cmake-make:bootstrap"|"autotools:bootstrap"|"make:bootstrap")
make install ${PKG_MAKEINSTALL_OPTS_BOOTSTRAP}
;;
esac
fi
pkg_call_exists_opt post_makeinstall_${TARGET} && pkg_call
record_timestamp BUILD_COPY_SYSROOT
# Fixup temporary sysroot references to the shared sysroot
for i in $(find "${SYSROOT_PREFIX}/usr/lib" -type f -name "*.la" 2>/dev/null); do
sed -e "s:\(['= ]\)/usr:\\1${PKG_ORIG_SYSROOT_PREFIX}/usr:g" -i "${i}"
done
for i in $(find "${SYSROOT_PREFIX}/usr/bin" -type f -name "*-config" 2>/dev/null); do
sed -e "s#${SYSROOT_PREFIX}/usr#${PKG_ORIG_SYSROOT_PREFIX}/usr#g" -i "${i}"
done
for i in $(find "${SYSROOT_PREFIX}/usr/lib" -type f -name "*.pc" 2>/dev/null); do
sed -e "s#${SYSROOT_PREFIX}/usr#${PKG_ORIG_SYSROOT_PREFIX}/usr#g" -i "${i}"
done
for i in $(find "${SYSROOT_PREFIX}/usr"/{lib,share} -type f -name "*.cmake" 2>/dev/null); do
sed -e "s#${SYSROOT_PREFIX}/usr#${PKG_ORIG_SYSROOT_PREFIX}/usr#g" -i "${i}"
done
for i in $(find "${SYSROOT_PREFIX}" -type l 2>/dev/null); do
_tmp="$(readlink -m "${i}")"
[[ ${_tmp} =~ ^/usr ]] && _tmp="${SYSROOT_PREFIX}${_tmp}"
if [[ ${_tmp} =~ ^${SYSROOT_PREFIX}/ ]]; then
ln -sfn "${_tmp/${SYSROOT_PREFIX}\//${PKG_ORIG_SYSROOT_PREFIX}\/}" "${i}"
fi
done
# Transfer the new sysroot content to the shared sysroot
acquire_update_lock sysroot
mkdir -p "${PKG_ORIG_SYSROOT_PREFIX}"
cp -PRf "${SYSROOT_PREFIX}"/* "${PKG_ORIG_SYSROOT_PREFIX}"
release_update_lock
rm -rf "${SYSROOT_PREFIX}"
export SYSROOT_PREFIX="${PKG_ORIG_SYSROOT_PREFIX}"
record_timestamp BUILD_CLEANUP_INSTALL
if [ "${TARGET}" = "target" -o "${TARGET}" = "init" ]; then
if [ -d ${INSTALL} ]; then
rm -rf ${INSTALL}/{usr/local/,usr/,}man
rm -rf ${INSTALL}/{usr/local/,usr/,}share/bash-completion
rm -rf ${INSTALL}/{usr/local/,usr/,}share/doc
rm -rf ${INSTALL}/{usr/local/,usr/,}share/gtk-doc
rm -rf ${INSTALL}/{usr/local/,usr/,}share/info
rm -rf ${INSTALL}/{usr/local/,usr/,}share/locale
rm -rf ${INSTALL}/{usr/local/,usr/,}share/man
rm -rf ${INSTALL}/{usr/local/,usr/,}share/zsh
rm -rf ${INSTALL}/{usr/local/,usr/,}var
find ${INSTALL} \( -name "*.orig" \
-o -name "*.rej" \
-o -name "*.in" \
-o -name ".git*" \) \
-exec rm -f {} \; 2>/dev/null || :
find ${INSTALL} -type d -exec rmdir -p {} \; 2>/dev/null || :
python_fix_abi "${INSTALL}"
if [ "${BUILD_WITH_DEBUG}" != "yes" ] && flag_enabled "strip" "yes"; then
${STRIP} $(find ${INSTALL} \
-type f -name "*.so*" \
! -name "ld-*.so" \
! -name "libc-*.so" \
! -name "libpthread-*.so" \
! -name "libthread_db-*so" \
2>/dev/null) 2>/dev/null || :
if [ "${TARGET}" = "init" ]; then
${STRIP} $(find ${INSTALL} -type f -name "*.so*" 2>/dev/null) 2>/dev/null || :
fi
${STRIP} $(find ${INSTALL} ! -name "*.so*" ! -name "*.ko" \
-type f -executable 2>/dev/null) 2>/dev/null || :
fi
fi
fi
if [ -n "${INSTALL}" -a -d "${INSTALL}" ]; then
echo "INFO_PKG_NAME=\"${PKG_NAME}\"" > "${INSTALL}/.libreelec-package"
fi
cd ${ROOT}
PKG_DEEPHASH=$(calculate_stamp)
for i in PKG_NAME PKG_DEEPHASH BUILD_WITH_DEBUG; do
echo "STAMP_${i}=\"${!i}\"" >> ${STAMP}
done
pkg_lock_status "UNLOCK" "${PKG_NAME}:${TARGET}" "build" "built"
record_timestamp BUILD_END
if [ -n "${TRACE_BUILD_TIMING}" ]; then
(
print_color "CLR_AUTOREMOVE" "\nBuild timing details:"
print_color "CLR_TARGET" "\n================================\n"
show_timestamp_diff "unpack" BUILD_BEGIN BUILD_START
show_timestamp_diff "pre-build setup" BUILD_START BUILD_CONFIGURE
show_timestamp_diff "configure" BUILD_CONFIGURE BUILD_MAKE
show_timestamp_diff "make" BUILD_MAKE BUILD_MAKEINSTALL
show_timestamp_diff "make install" BUILD_MAKEINSTALL BUILD_COPY_SYSROOT
show_timestamp_diff "copy sysroot" BUILD_COPY_SYSROOT BUILD_CLEANUP_INSTALL
show_timestamp_diff "cleanup install" BUILD_CLEANUP_INSTALL BUILD_END
print_color "CLR_TARGET" "--------------------------------\n"
show_timestamp_diff "total time" BUILD_BEGIN BUILD_END
echo -e
) >&${VERBOSE_OUT}
fi
Reference in New Issue View Git Blame Copy Permalink