mirror of
https://github.com/gentoo-mirror/gentoo.git
synced 2026-08-05 12:38:09 -07:00
cbd0187656
While this shouldn't be modified, there's also no real need to protect it. Removing feels more consistent with what classes do in general (aka not have readonly everywhere). Signed-off-by: Ionen Wolkens <ionen@gentoo.org>
587 lines
20 KiB
Bash
587 lines
20 KiB
Bash
# Copyright 2025-2026 Gentoo Authors
|
|
# Distributed under the terms of the GNU General Public License v2
|
|
|
|
# @ECLASS: wine.eclass
|
|
# @MAINTAINER:
|
|
# Wine <wine@gentoo.org>
|
|
# @AUTHOR:
|
|
# Ionen Wolkens <ionen@gentoo.org>
|
|
# @SUPPORTED_EAPIS: 8
|
|
# @BLURB: Common functions for app-emuluation/wine-* ebuilds
|
|
# @DESCRIPTION:
|
|
# Given the large amount of Wine ebuilds (and variants) that need
|
|
# duplicated code, this is used to offload the more complex bits
|
|
# (primarily toolchain and slotting) and leave ebuilds to only need
|
|
# to deal with dependencies and configure options like any other.
|
|
#
|
|
# Note to overlays: this can be used to package other variants of
|
|
# Wine, but there is currently no garantee that eclass changes may
|
|
# not break these ebuilds now and then without real warnings
|
|
|
|
case ${EAPI} in
|
|
8) ;;
|
|
*) die "${ECLASS}: EAPI ${EAPI:-0} not supported" ;;
|
|
esac
|
|
|
|
if [[ -z ${_WINE_ECLASS} ]]; then
|
|
_WINE_ECLASS=1
|
|
|
|
inherit autotools flag-o-matic multilib prefix toolchain-funcs wrapper
|
|
|
|
# @ECLASS_VARIABLE: WINE_USEDEP
|
|
# @DESCRIPTION:
|
|
# Meant be used like multilib-build.eclass' MULTILIB_USEDEP. Handled
|
|
# specially here given Wine ebuilds are not *really* multilib and are
|
|
# abusing abi_x86_* with some specific requirements.
|
|
#
|
|
# TODO: when the *new* wow64 mode (aka USE=wow64) is mature enough to
|
|
# be about always preferred over abi_x86_32, this should be removed and
|
|
# support for 32bit-only-on-64bit be dropped matching how /no-multilib/
|
|
# handles it
|
|
WINE_USEDEP="abi_x86_32(-)?,abi_x86_64(-)?"
|
|
|
|
IUSE="+abi_x86_64 arm64ec crossdev-mingw custom-cflags +mingw +strip"
|
|
|
|
# enable wow64 in wine-11+ where it is no longer considered experimental
|
|
# and provides a better UX for Gentoo users without USE=abi_x86_32
|
|
if ver_test -ge 11; then
|
|
IUSE+=" abi_x86_32 +wow64"
|
|
else
|
|
IUSE+=" +abi_x86_32 wow64"
|
|
fi
|
|
|
|
REQUIRED_USE="
|
|
|| ( abi_x86_32 abi_x86_64 arm64 )
|
|
crossdev-mingw? ( mingw )
|
|
wow64? ( !arm64? ( abi_x86_64 !abi_x86_32 ) )
|
|
"
|
|
|
|
RDEPEND="
|
|
arm64? ( wow64? ( app-emulation/fex-xtajit[wow64(+)] ) )
|
|
arm64ec? ( app-emulation/fex-xtajit[arm64ec(-)] )
|
|
"
|
|
BDEPEND="
|
|
|| (
|
|
sys-devel/binutils:*
|
|
llvm-core/lld:*
|
|
)
|
|
dev-lang/perl
|
|
mingw? (
|
|
!crossdev-mingw? (
|
|
wow64? ( dev-util/mingw64-toolchain[abi_x86_32] )
|
|
!wow64? ( dev-util/mingw64-toolchain[${WINE_USEDEP}] )
|
|
)
|
|
)
|
|
!mingw? (
|
|
llvm-core/clang:*
|
|
llvm-core/lld:*
|
|
strip? ( llvm-core/llvm:* )
|
|
)
|
|
"
|
|
IDEPEND=">=app-eselect/eselect-wine-2"
|
|
|
|
# @ECLASS_VARIABLE: WINE_SKIP_INSTALL
|
|
# @DESCRIPTION:
|
|
# Array of files to delete from the installation relative
|
|
# to ${ED}, must be set before running wine_src_install.
|
|
WINE_SKIP_INSTALL=()
|
|
|
|
# @FUNCTION: wine_pkg_pretend
|
|
# @DESCRIPTION:
|
|
# Verifies if crossdev-mingw is used properly, ignored if
|
|
# ``MINGW_BYPASS`` is set.
|
|
wine_pkg_pretend() {
|
|
[[ ${MERGE_TYPE} == binary ]] && return
|
|
|
|
if use crossdev-mingw && [[ ! -v MINGW_BYPASS ]]; then
|
|
local arches=(
|
|
$(usev abi_x86_64 x86_64)
|
|
$(usev abi_x86_32 i686)
|
|
$(usev wow64 i686)
|
|
$(usev arm64 aarch64)
|
|
$(usev arm64ec arm64ec)
|
|
)
|
|
|
|
local mingw
|
|
for mingw in "${arches[@]/%/-w64-mingw32}"; do
|
|
if ! type -P ${mingw}-gcc >/dev/null; then
|
|
eerror "With USE=crossdev-mingw, you must prepare the MinGW toolchain"
|
|
eerror "yourself by installing sys-devel/crossdev then running:"
|
|
eerror
|
|
eerror " crossdev --target ${mingw}"
|
|
eerror
|
|
eerror "For more information, please see: https://wiki.gentoo.org/wiki/Mingw"
|
|
die "USE=crossdev-mingw is enabled, but ${mingw}-gcc was not found"
|
|
fi
|
|
done
|
|
fi
|
|
}
|
|
|
|
# @FUNCTION: wine_src_prepare
|
|
# @DESCRIPTION:
|
|
# Apply various minor adjustments, run eautoreconf, make_requests, and
|
|
# perform a version mismatch sanity check if WINE_GECKO and WINE_MONO
|
|
# are set.
|
|
#
|
|
# If need more than make_requests, it should be either handled in
|
|
# the ebuild or (for users) optionally through portage hooks, e.g.
|
|
#
|
|
# @CODE
|
|
# echo "post_src_prepare() { tools/make_specfiles || die; }" \
|
|
# > /etc/portage/env/app-emulation/wine-vanilla
|
|
# @CODE
|
|
wine_src_prepare() {
|
|
default
|
|
|
|
if [[ ${WINE_GECKO} && ${WINE_MONO} ]]; then
|
|
# sanity check, bumping these has a history of oversights
|
|
local geckomono=$(sed -En '/^#define (GECKO|MONO)_VER/{s/[^0-9.]//gp}' \
|
|
dlls/appwiz.cpl/addons.c || die)
|
|
|
|
if [[ ${WINE_GECKO}$'\n'${WINE_MONO} != "${geckomono}" ]]; then
|
|
local gmfatal=
|
|
has live ${PROPERTIES} && gmfatal=nonfatal
|
|
${gmfatal} die -n "gecko/mono mismatch in ebuild, has: " ${geckomono} " (please file a bug)"
|
|
fi
|
|
fi
|
|
|
|
if tc-is-clang && use mingw; then
|
|
# -mabi=ms was ignored by <clang:16 then turned error in :17
|
|
# if used without --target *-windows, then gets used in install
|
|
# phase despite USE=mingw, drop as a quick fix for now
|
|
sed -i '/MSVCRTFLAGS=/s/-mabi=ms//' configure.ac || die
|
|
fi
|
|
|
|
# ensure .desktop calls this variant + slot
|
|
sed -i "/^Exec=/s/wine /${P} /" loader/wine.desktop || die
|
|
|
|
# needed to find wine-mono on prefix
|
|
hprefixify -w /get_mono_path/ dlls/mscoree/metahost.c
|
|
|
|
# always update for patches (including user's wrt #432348)
|
|
eautoreconf
|
|
tools/make_requests || die # perl
|
|
}
|
|
|
|
# @FUNCTION: wine_src_configure
|
|
# @DESCRIPTION:
|
|
# Setup toolchain and run ./configure by passing the ``wineconfargs``
|
|
# array.
|
|
#
|
|
# The following options are handled automatically and do not need
|
|
# to be passed: --prefix (and similar), --enable-archs, --enable-win64
|
|
# --with-mingw, and --with-wine64
|
|
#
|
|
# Can adjust cross toolchain using CROSSCC, CROSSCC_amd64/x86/arm64,
|
|
# CROSS{C,LD}FLAGS, CROSS{C,LD}FLAGS_amd64/x86/arm64, and likewise
|
|
# for CROSSCXX (variable naming is mostly historical because wine
|
|
# itself used to recognize CROSSCC). Be warned that changing FLAGS
|
|
# is fragile and unsupported. If USE=custom-cflags, the native
|
|
# toolchain's FLAGS will be used, otherwise the default is just -O2.
|
|
wine_src_configure() {
|
|
WINE_PREFIX=/usr/lib/${P}
|
|
WINE_DATADIR=/usr/share/${P}
|
|
WINE_INCLUDEDIR=/usr/include/${P}
|
|
|
|
local conf=(
|
|
--prefix="${EPREFIX}"${WINE_PREFIX}
|
|
--datadir="${EPREFIX}"${WINE_DATADIR}
|
|
--includedir="${EPREFIX}"${WINE_INCLUDEDIR}
|
|
--libdir="${EPREFIX}"${WINE_PREFIX}
|
|
--mandir="${EPREFIX}"${WINE_DATADIR}/man
|
|
)
|
|
|
|
if use !custom-cflags; then
|
|
# wine is generally fragile
|
|
strip-flags
|
|
append-flags $(test-flags-CC -fno-stack-protector) #870136,#970983
|
|
fi
|
|
|
|
# longstanding failing to build with lto, filter unconditionally
|
|
filter-lto
|
|
|
|
# may segfault at runtime if used (bug #931329)
|
|
filter-flags -Wl,--gc-sections
|
|
|
|
# avoid gcc-15's c23 default with older wine (bug #943849)
|
|
ver_test -lt 10 && append-cflags -std=gnu17
|
|
|
|
# Wine uses many linker tricks that are unlikely to work
|
|
# with anything but bfd or lld (bug #867097)
|
|
if ! tc-ld-is-bfd && ! tc-ld-is-lld; then
|
|
has_version -b sys-devel/binutils &&
|
|
append-ldflags -fuse-ld=bfd ||
|
|
append-ldflags -fuse-ld=lld
|
|
strip-unsupported-flags
|
|
fi
|
|
|
|
# wcc_* variables are used by _wine_flags(), see that
|
|
# function if need to adjust *FLAGS only for cross
|
|
local w{cc,cxx}_{amd64,x86,arm64,arm64ec}{,_testflags}
|
|
# TODO?: llvm-mingw support if useful
|
|
if use mingw; then
|
|
conf+=( --with-mingw )
|
|
|
|
use !crossdev-mingw &&
|
|
! has_version -b 'dev-util/mingw64-toolchain[bin-symlinks]' &&
|
|
PATH=${BROOT}/usr/lib/mingw64-toolchain/bin:${PATH}
|
|
|
|
wcc_amd64=${CROSSCC:-${CROSSCC_amd64:-x86_64-w64-mingw32-gcc}}
|
|
wcxx_amd64=${CROSSCXX:-${CROSSCXX_amd64:-x86_64-w64-mingw32-g++}}
|
|
|
|
wcc_x86=${CROSSCC:-${CROSSCC_x86:-i686-w64-mingw32-gcc}}
|
|
wcxx_x86=${CROSSCXX:-${CROSSCXX_x86:-i686-w64-mingw32-g++}}
|
|
|
|
# no mingw64-toolchain ~arm64, but "may" be usable with crossdev
|
|
# (aarch64- rather than arm64- given it is what Wine searches for)
|
|
wcc_arm64=${CROSSCC:-${CROSSCC_arm64:-aarch64-w64-mingw32-gcc}}
|
|
wcxx_arm64=${CROSSCXX:-${CROSSCXX_arm64:-aarch64-w64-mingw32-g++}}
|
|
|
|
wcc_arm64ec=${CROSSCC:-${CROSSCC_arm64ec:-arm64ec-w64-mingw32-gcc}}
|
|
wcxx_arm64ec=${CROSSCXX:-${CROSSCXX_arm64ec:-arm64ec-w64-mingw32-g++}}
|
|
else
|
|
conf+=( --with-mingw=clang )
|
|
|
|
# not building for ${CHOST} so $(tc-getCC) is not quite right, but
|
|
# *should* support -target *-windows regardless (testflags is only
|
|
# used by _wine_flags(), wine handles -target by itself)
|
|
local clang=clang clangxx=clang++
|
|
if tc-is-clang; then
|
|
clang=$(tc-getCC)
|
|
clangxx=$(tc-getCXX)
|
|
fi
|
|
|
|
wcc_amd64=${CROSSCC:-${CROSSCC_amd64:-${clang}}}
|
|
wcc_amd64_testflags="-target x86_64-windows"
|
|
wcxx_amd64=${CROSSCXX:-${CROSSCXX_amd64:-${clangxx}}}
|
|
wcxx_amd64_testflags=${wcc_amd64_testflags}
|
|
|
|
wcc_x86=${CROSSCC:-${CROSSCC_x86:-${clang}}}
|
|
wcc_x86_testflags="-target i386-windows"
|
|
wcxx_x86=${CROSSCXX:-${CROSSCXX_x86:-${clangxx}}}
|
|
wcxx_x86_testflags=${wcc_x86_testflags}
|
|
|
|
wcc_arm64=${CROSSCC:-${CROSSCC_arm64:-${clang}}}
|
|
wcc_arm64_testflags="-target aarch64-windows"
|
|
wcxx_arm64=${CROSSCXX:-${CROSSCXX_arm64:-${clangxx}}}
|
|
wcxx_arm64_testflags=${wcc_arm64_testflags}
|
|
|
|
wcc_arm64ec=${CROSSCC:-${CROSSCC_arm64ec:-${clang}}}
|
|
wcc_arm64ec_testflags="-target arm64ec-windows"
|
|
wcxx_arm64ec=${CROSSCXX:-${CROSSCXX_arm64ec:-${clangxx}}}
|
|
wcxx_arm64ec_testflags=${wcc_arm64ec_testflags}
|
|
|
|
# do not copy from regular LDFLAGS given odds are they all are
|
|
# incompatible, and difficult to test linking without llvm-mingw
|
|
: "${CROSSLDFLAGS:= }"
|
|
fi
|
|
|
|
conf+=(
|
|
ac_cv_prog_x86_64_CC="${wcc_amd64}"
|
|
ac_cv_prog_x86_64_CXX="${wcxx_amd64}"
|
|
ac_cv_prog_i386_CC="${wcc_x86}"
|
|
ac_cv_prog_i386_CXX="${wcxx_x86}"
|
|
ac_cv_prog_aarch64_CC="${wcc_arm64}"
|
|
ac_cv_prog_aarch64_CXX="${wcxx_arm64}"
|
|
ac_cv_prog_arm64ec_CC="${wcc_arm64ec}"
|
|
ac_cv_prog_arm64ec_CXX="${wcxx_arm64ec}"
|
|
|
|
)
|
|
|
|
if ver_test -ge 10; then
|
|
# TODO: merge with the av_cv array above when <wine-10 is gone
|
|
conf+=(
|
|
# if set, use CROSS*FLAGS as-is without filtering
|
|
x86_64_CFLAGS="${CROSSCFLAGS_amd64:-${CROSSCFLAGS:-$(_wine_flags c amd64)}}"
|
|
x86_64_CXXFLAGS="${CROSSCXXFLAGS_amd64:-${CROSSCXXFLAGS:-$(_wine_flags cxx amd64)}}"
|
|
x86_64_LDFLAGS="${CROSSLDFLAGS_amd64:-${CROSSLDFLAGS:-$(_wine_flags ld amd64)}}"
|
|
i386_CFLAGS="${CROSSCFLAGS_x86:-${CROSSCFLAGS:-$(_wine_flags c x86)}}"
|
|
i386_CXXFLAGS="${CROSSCXXFLAGS_x86:-${CROSSCXXFLAGS:-$(_wine_flags cxx x86)}}"
|
|
i386_LDFLAGS="${CROSSLDFLAGS_x86:-${CROSSLDFLAGS:-$(_wine_flags ld x86)}}"
|
|
aarch64_CFLAGS="${CROSSCFLAGS_arm64:-${CROSSCFLAGS:-$(_wine_flags c arm64)}}"
|
|
aarch64_CXXFLAGS="${CROSSCXXFLAGS_arm64:-${CROSSCXXFLAGS:-$(_wine_flags cxx arm64)}}"
|
|
aarch64_LDFLAGS="${CROSSLDFLAGS_arm64:-${CROSSLDFLAGS:-$(_wine_flags ld arm64)}}"
|
|
arm64ec_CFLAGS="${CROSSCFLAGS_arm64ec:-${CROSSCFLAGS:-$(_wine_flags c arm64ec)}}"
|
|
arm64ec_CXXFLAGS="${CROSSCXXFLAGS_arm64ec:-${CROSSCXXFLAGS:-$(_wine_flags cxx arm64ec)}}"
|
|
arm64ec_LDFLAGS="${CROSSLDFLAGS_arm64ec:-${CROSSLDFLAGS:-$(_wine_flags ld arm64ec)}}"
|
|
)
|
|
elif use abi_x86_64; then
|
|
conf+=(
|
|
# per-arch flags are only respected with >=wine-10,
|
|
# do a one-arch best effort fallback
|
|
CROSSCFLAGS="${CROSSCFLAGS_amd64:-${CROSSCFLAGS:-$(_wine_flags c amd64)}}"
|
|
CROSSLDFLAGS="${CROSSLDFLAGS_amd64:-${CROSSLDFLAGS:-$(_wine_flags ld amd64)}}"
|
|
)
|
|
elif use abi_x86_32; then
|
|
conf+=(
|
|
CROSSCFLAGS="${CROSSCFLAGS_x86:-${CROSSCFLAGS:-$(_wine_flags c x86)}}"
|
|
CROSSLDFLAGS="${CROSSLDFLAGS_x86:-${CROSSLDFLAGS:-$(_wine_flags ld x86)}}"
|
|
)
|
|
fi
|
|
|
|
if use abi_x86_64 && use abi_x86_32 && use !wow64; then
|
|
# multilib dual build method for "old" wow64 (must do 64 first)
|
|
local bits
|
|
for bits in 64 32; do
|
|
(
|
|
einfo "Configuring for ${bits}bits in ${WORKDIR}/build${bits} ..."
|
|
|
|
mkdir ../build${bits} || die
|
|
cd ../build${bits} || die
|
|
|
|
if (( bits == 64 )); then
|
|
conf+=( --enable-win64 )
|
|
else
|
|
conf+=(
|
|
--with-wine64=../build64
|
|
TARGETFLAGS=-m32 # for widl
|
|
)
|
|
|
|
# optional, but prefer over Wine's auto-detect (+#472038)
|
|
multilib_toolchain_setup x86
|
|
fi
|
|
|
|
ECONF_SOURCE=${S} econf "${conf[@]}" "${wineconfargs[@]}"
|
|
)
|
|
done
|
|
else
|
|
# new --enable-archs method, or 32bit-only
|
|
local archs=(
|
|
$(usev abi_x86_64 x86_64)
|
|
$(usev wow64 i386) # 32-on-64bit "new" wow64
|
|
$(usev arm64 aarch64)
|
|
$(usev arm64ec arm64ec)
|
|
)
|
|
conf+=( ${archs:+--enable-archs="${archs[*]}"} )
|
|
|
|
if use amd64 && use !abi_x86_64; then
|
|
# same as above for 32bit-only on 64bit (allowed for wine)
|
|
conf+=( TARGETFLAGS=-m32 )
|
|
multilib_toolchain_setup x86
|
|
fi
|
|
|
|
econf "${conf[@]}" "${wineconfargs[@]}"
|
|
fi
|
|
}
|
|
|
|
# @FUNCTION: wine_src_compile
|
|
# @DESCRIPTION:
|
|
# Handle running emake.
|
|
wine_src_compile() {
|
|
if use abi_x86_64 && use abi_x86_32 && use !wow64; then
|
|
emake -C ../build64 # do first
|
|
emake -C ../build32
|
|
else
|
|
emake
|
|
fi
|
|
}
|
|
|
|
# @FUNCTION: wine_src_install
|
|
# @DESCRIPTION:
|
|
# Handle running emake install, creating slot wrappers, and
|
|
# stripping binaries built for Windows.
|
|
wine_src_install() {
|
|
if use abi_x86_64 && use abi_x86_32 && use !wow64; then
|
|
emake DESTDIR="${D}" -C ../build32 install
|
|
emake DESTDIR="${D}" -C ../build64 install # do last
|
|
else
|
|
emake DESTDIR="${D}" install
|
|
fi
|
|
|
|
if use abi_x86_64 || use arm64; then
|
|
if ver_test -ge 10.2; then
|
|
# wine64 was removed, but keep a symlink for old scripts
|
|
# TODO: can remove this -e guard eventually, only there to
|
|
# avoid overwriting 9999's wine64 if go into <10.2 commits
|
|
[[ ! -e ${ED}${WINE_PREFIX}/bin/wine64 ]] &&
|
|
dosym wine ${WINE_PREFIX}/bin/wine64
|
|
else
|
|
# <wine-10.2 did not have a unified wine(1) and could miss
|
|
# wine64 or wine depending on USE, ensure both are are there
|
|
if [[ -e ${ED}${WINE_PREFIX}/bin/wine64 && ! -e ${ED}${WINE_PREFIX}/bin/wine ]]; then
|
|
dosym wine64 ${WINE_PREFIX}/bin/wine
|
|
dosym wine64-preloader ${WINE_PREFIX}/bin/wine-preloader
|
|
elif [[ ! -e ${ED}${WINE_PREFIX}/bin/wine64 && -e ${ED}${WINE_PREFIX}/bin/wine ]]; then
|
|
dosym wine ${WINE_PREFIX}/bin/wine64
|
|
dosym wine-preloader ${WINE_PREFIX}/bin/wine64-preloader
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
use arm64 && use wow64 &&
|
|
dosym -r /usr/lib/fex-xtajit/libwow64fex.dll \
|
|
${WINE_PREFIX}/wine/aarch64-windows/xtajit.dll
|
|
|
|
use arm64ec &&
|
|
dosym -r /usr/lib/fex-xtajit/libarm64ecfex.dll \
|
|
${WINE_PREFIX}/wine/aarch64-windows/xtajit64.dll
|
|
|
|
# delete unwanted files if requested, not done directly in ebuilds
|
|
# given must be done after install and before wrappers
|
|
if (( ${#WINE_SKIP_INSTALL[@]} )); then
|
|
rm -- "${WINE_SKIP_INSTALL[@]/#/${ED}}" || die
|
|
fi
|
|
|
|
# create variant wrappers for eselect-wine
|
|
local bin
|
|
for bin in "${ED}"${WINE_PREFIX}/bin/*; do
|
|
make_wrapper "${bin##*/}-${P#wine-}" "${bin#"${ED}"}"
|
|
done
|
|
|
|
# don't let the package manager try to strip Windows files with
|
|
# potentially the wrong strip executable and instead handle it here
|
|
dostrip -x ${WINE_PREFIX}/wine/{x86_64,i386,aarch64}-windows
|
|
|
|
if use strip; then
|
|
ebegin "Stripping Windows binaries"
|
|
if use mingw; then
|
|
: "$(usex arm64 aarch64 $(usex abi_x86_64 x86_64 i686)-w64-mingw32-strip)"
|
|
find "${ED}"${WINE_PREFIX}/wine/*-windows -regex '.*\.\(a\|dll\|exe\)' \
|
|
-type f -exec ${_} --strip-unneeded {} +
|
|
else
|
|
# llvm-strip errors on .a, and CHOST binutils strip could mangle
|
|
find "${ED}"${WINE_PREFIX}/wine/*-windows -regex '.*\.\(dll\|exe\)' \
|
|
-type f -exec llvm-strip --strip-unneeded {} +
|
|
fi
|
|
eend ${?} || die
|
|
fi
|
|
}
|
|
|
|
# @FUNCTION: wine_pkg_preinst
|
|
# @DESCRIPTION:
|
|
# This should *not* be called directly, if need to declare your own
|
|
# pkg_preinst, then simply do not call this.
|
|
#
|
|
# This is a temporary helper to warn about a default USE change,
|
|
# that should be removed after 6+ months of >=wine-11.0 being stable
|
|
# (also remove the pkg_preinst EXPORT and warning in wine_pkg_postinst).
|
|
wine_pkg_preinst() {
|
|
# if *any* slot has it set or it is a new install, then assume
|
|
# user does not need a warning
|
|
use wow64 && ver_test -ge 11 && has_version "${CATEGORY}/${PN}" &&
|
|
! has_version "${CATEGORY}/${PN}[wow64(-)]" && WINE_WARN_WOW64=
|
|
}
|
|
|
|
# @FUNCTION: wine_pkg_postinst
|
|
# @DESCRIPTION:
|
|
# Provide generic warnings about missing 32bit support,
|
|
# and run eselect wine update.
|
|
wine_pkg_postinst() {
|
|
# on amd64, users sometime disable the default 32bit support due to being
|
|
# annoyed by the requirements without realizing that they need it
|
|
if use amd64 && use !abi_x86_32 && use !wow64; then
|
|
ewarn
|
|
ewarn "32bit support is disabled. While 64bit applications themselves will"
|
|
ewarn "work, be warned that it is not unusual that installers or other helpers"
|
|
ewarn "will attempt to use 32bit and fail. If do not want full USE=abi_x86_32,"
|
|
ewarn "note the experimental USE=wow64 can allow 32bit without full multilib."
|
|
fi
|
|
|
|
# difficult to tell what is needed from here, but try to warn anyway
|
|
if use abi_x86_32 && { use opengl || use vulkan; }; then
|
|
if has_version 'x11-drivers/nvidia-drivers'; then
|
|
if has_version 'x11-drivers/nvidia-drivers[-abi_x86_32]'; then
|
|
ewarn
|
|
ewarn "x11-drivers/nvidia-drivers is installed but is built without"
|
|
ewarn "USE=abi_x86_32 (ABI_X86=32), hardware acceleration with 32bit"
|
|
ewarn "applications under ${PN} will likely not be usable."
|
|
ewarn "Multi-card setups may need this on media-libs/mesa as well."
|
|
fi
|
|
elif has_version 'media-libs/mesa[-abi_x86_32]'; then
|
|
ewarn
|
|
ewarn "media-libs/mesa seems to be in use but is built without"
|
|
ewarn "USE=abi_x86_32 (ABI_X86=32), hardware acceleration with 32bit"
|
|
ewarn "applications under ${PN} will likely not be usable."
|
|
fi
|
|
fi
|
|
|
|
# see wine_pkg_preinst
|
|
if [[ -v WINE_WARN_WOW64 ]]; then
|
|
ewarn
|
|
ewarn "This version of Wine now enables USE=wow64 and disables USE=abi_x86_32"
|
|
ewarn "by default. This removes the need to set USE=abi_x86_32 on most of"
|
|
ewarn "Wine's dependencies while still being able to run 32bit applications."
|
|
ewarn "If experience issues, can be reverted with USE='abi_x86_32 -wow64'."
|
|
fi
|
|
|
|
eselect wine update --if-unset || die
|
|
}
|
|
|
|
# @FUNCTION: wine_pkg_postrm
|
|
# @DESCRIPTION:
|
|
# Run eselect wine update if available.
|
|
wine_pkg_postrm() {
|
|
if has_version -b app-eselect/eselect-wine; then
|
|
eselect wine update --if-unset || die
|
|
fi
|
|
}
|
|
|
|
# @FUNCTION: _wine_flags
|
|
# @USAGE: <c|cxx|ld> <arch>
|
|
# @INTERNAL
|
|
# @DESCRIPTION:
|
|
# Filter and test current {C,CXX,LD}FLAGS for usage with the cross
|
|
# toolchain (using ``wcc_*`` and ``wcxx_*`` variables, see
|
|
# wine_src_configure), and echo back working flags.
|
|
#
|
|
# Note that this ignores checking USE for simplicity, if compiler
|
|
# is unusable (e.g. not found) then it will return empty flags
|
|
# which is fine.
|
|
_wine_flags() {
|
|
local -n wcc=wcc_${2} wccflags=wcc_${2}_testflags
|
|
local -x CC="${wcc} ${wccflags}"
|
|
|
|
local -n wcxx=wcxx_${2} wcxxflags=wcxx_${2}_testflags
|
|
local -x CXX="${wcxx} ${wcxxflags}"
|
|
|
|
case ${1} in
|
|
c|cxx)
|
|
if use mingw && use !custom-cflags; then
|
|
# Changing CROSS*FLAGS is not very tested and often cause
|
|
# problems even with simple things like -march=native/-O3 when
|
|
# using mingw-gcc (thus -mno-avx below, also bug #960825), only
|
|
# inherit basic flags from CFLAGS unless USE=custom-cflags.
|
|
#
|
|
# Note that users setting CROSS*FLAGS directly (unfiltered)
|
|
# are on their own just like with USE=custom-cflags.
|
|
local -n flags=${1^^}FLAGS
|
|
local flag kept=
|
|
# TODO: can drop |-std=* when <wine-10 is gone
|
|
for flag in ${flags}; do
|
|
[[ ${flag} == @(-g*|-O[0-2g]|-fno-stack*|-std=*) ]] &&
|
|
kept+=" ${flag}"
|
|
done
|
|
flags=${kept:--O2}
|
|
else
|
|
filter-flags '-mfunction-return=thunk*' #878849
|
|
|
|
# bashrc-mv users often do CFLAGS="${LDFLAGS}" and then
|
|
# compile-only tests miss stripping unsupported linker flags
|
|
filter-flags '-Wl,*'
|
|
|
|
# -mavx with mingw-gcc has a history of problems and still see
|
|
# users have issues despite Wine's -mpreferred-stack-boundary=2
|
|
# (kept even with USE=custom-cflags wrt bug #912268)
|
|
use mingw && append-flags -mno-avx
|
|
fi
|
|
|
|
# same as strip-unsupported-flags but echos only for CC/CXX
|
|
if [[ ${1} == c ]]; then
|
|
test-flags-CC ${CFLAGS}
|
|
else
|
|
test-flags-CXX ${CXXFLAGS}
|
|
fi
|
|
;;
|
|
ld)
|
|
# let compiler figure out the right linker for cross
|
|
filter-flags '-fuse-ld=*'
|
|
|
|
test-flags-CCLD ${LDFLAGS}
|
|
;;
|
|
esac
|
|
}
|
|
|
|
fi
|
|
|
|
EXPORT_FUNCTIONS pkg_pretend src_prepare src_configure src_compile src_install pkg_preinst pkg_postinst pkg_postrm
|