$ cat /var/tmp/portage/app-admin/doas-6.8.2/temp/build.log

 * Package:	app-admin/doas-6.8.2:0
 * Repository: gentoo
 * Maintainer: felix.janda@posteo.de proxy-maint@gentoo.org
 * USE:    	abi_x86_64 amd64 elibc_glibc kernel_linux pam persist
 * FEATURES:   network-sandbox preserve-libs sandbox userpriv usersandbox
>>> Unpacking source...
>>> Unpacking OpenDoas-6.8.2.tar.gz to /var/tmp/portage/app-admin/doas-6.8.2/work
>>> Source unpacked in /var/tmp/portage/app-admin/doas-6.8.2/work
>>> Preparing source in /var/tmp/portage/app-admin/doas-6.8.2/work/OpenDoas-6.8.2 ...
>>> Source prepared.
>>> Configuring source in /var/tmp/portage/app-admin/doas-6.8.2/work/OpenDoas-6.8.2 ...
Checking for explicit_bzero ...    	yes.
Checking for strlcat ...       	yes.
Checking for strlcpy ...       	yes.
Checking for errc ...          	no.
Checking for verrc ...         	no.
Checking for setprogname ...    	no.
Checking for readpassphrase ...    	no.
Checking for strtonum ...      	no.
Checking for reallocarray ...    	yes.
Checking for execvpe ...       	yes.
Checking for setresuid ...     	yes.
Checking for setresgid ...     	yes.
Checking for setreuid ...      	yes.
Checking for setregid ...      	yes.
Checking for closefrom ...     	yes.
Checking for sysconf ...       	yes.
Checking for dirfd ...         	yes.
Checking for fcntl_h ...       	yes.
Checking for F_CLOSEM ...      	no.
Checking for dirent_h ...      	yes.
Checking for sys_ndir_h ...    	no.
Checking for sys_dir_h ...     	yes.
Checking for ndir_h ...        	no.
Checking for login_cap_h ...    	no.
Checking for __attribute__ ...    	yes.
Checking for pam_appl_h ...    	yes.
Using auth method        	pam.
Using persist method        	timestamp.
>>> Source configured.
>>> Compiling source in /var/tmp/portage/app-admin/doas-6.8.2/work/OpenDoas-6.8.2 ...
make -j12
x86_64-pc-linux-gnu-gcc -I. -Ilibopenbsd -O2 -Wall -Wextra -D__msi__ -march=native -O2 -pipe   -c -o libopenbsd/progname.o libopenbsd/progname.c
x86_64-pc-linux-gnu-gcc -I. -Ilibopenbsd -O2 -Wall -Wextra -D__msi__ -march=native -O2 -pipe   -c -o libopenbsd/errc.o libopenbsd/errc.c
x86_64-pc-linux-gnu-gcc -I. -Ilibopenbsd -O2 -Wall -Wextra -D__msi__ -march=native -O2 -pipe   -c -o libopenbsd/strtonum.o libopenbsd/strtonum.c
yacc  parse.y
mv -f y.tab.c parse.c
x86_64-pc-linux-gnu-gcc -I. -Ilibopenbsd -O2 -Wall -Wextra -D__msi__ -march=native -O2 -pipe   -c -o libopenbsd/verrc.o libopenbsd/verrc.c
x86_64-pc-linux-gnu-gcc -I. -Ilibopenbsd -O2 -Wall -Wextra -D__msi__ -march=native -O2 -pipe   -c -o doas.o doas.c
doas.c: In function ‘parseuid’:
doas.c:58:29: error: ‘UID_MAX’ undeclared (first use in this function); did you mean ‘UINT_MAX’?
   58 |             	if (*uid == UID_MAX)
  	|                         	^~~~~~~
  	|                         	UINT_MAX
doas.c:58:29: note: each undeclared identifier is reported only once for each function it appears in
doas.c: In function ‘parsegid’:
doas.c:88:29: error: ‘GID_MAX’ undeclared (first use in this function)
   88 |             	if (*gid == GID_MAX)
  	|                         	^~~~~~~
doas.c: In function ‘checkconfig’:
doas.c:188:13: warning: implicit declaration of function ‘setresuid’; did you mean ‘setreuid’? [-Wimplicit-function-declaration]
  188 |     	if (setresuid(uid, uid, uid) != 0)
  	|         	^~~~~~~~~
  	|         	setreuid
doas.c: In function ‘main’:
doas.c:399:13: warning: implicit declaration of function ‘setresgid’; did you mean ‘setregid’? [-Wimplicit-function-declaration]
  399 |     	if (setresgid(targpw->pw_gid, targpw->pw_gid, targpw->pw_gid) != 0)
  	|         	^~~~~~~~~
  	|         	setregid
doas.c:430:9: warning: implicit declaration of function ‘execvpe’; did you mean ‘execvp’? [-Wimplicit-function-declaration]
  430 |     	execvpe(cmd, argv, envp);
  	|     	^~~~~~~
  	|     	execvp
make: *** [<builtin>: doas.o] Error 1
make: *** Waiting for unfinished jobs....
x86_64-pc-linux-gnu-gcc -I. -Ilibopenbsd -O2 -Wall -Wextra -D__msi__ -march=native -O2 -pipe   -c -o libopenbsd/readpassphrase.o libopenbsd/readpassphrase.c
libopenbsd/readpassphrase.c: In function ‘readpassphrase’:
libopenbsd/readpassphrase.c:135:23: warning: ignoring return value of ‘write’ declared with attribute ‘warn_unused_result’ [-Wunused-result]
  135 |             	(void)write(output, prompt, strlen(prompt));
  	|                   	^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
libopenbsd/readpassphrase.c:154:23: warning: ignoring return value of ‘write’ declared with attribute ‘warn_unused_result’ [-Wunused-result]
  154 |             	(void)write(output, "\n", 1);
  	|                   	^~~~~~~~~~~~~~~~~~~~~~
x86_64-pc-linux-gnu-gcc -I. -Ilibopenbsd -O2 -Wall -Wextra -D__msi__ -march=native -O2 -pipe   -c -o timestamp.o timestamp.c
x86_64-pc-linux-gnu-gcc -I. -Ilibopenbsd -O2 -Wall -Wextra -D__msi__ -march=native -O2 -pipe   -c -o pam.o pam.c
x86_64-pc-linux-gnu-gcc -I. -Ilibopenbsd -O2 -Wall -Wextra -D__msi__ -march=native -O2 -pipe   -c -o env.o env.c
x86_64-pc-linux-gnu-gcc -I. -Ilibopenbsd -O2 -Wall -Wextra -D__msi__ -march=native -O2 -pipe   -c -o parse.o parse.c
rm parse.c
 * ERROR: app-admin/doas-6.8.2::gentoo failed (compile phase):
 *   emake failed
 *
 * If you need support, post the output of `emerge --info '=app-admin/doas-6.8.2::gentoo'`,
 * the complete build log and the output of `emerge -pqv '=app-admin/doas-6.8.2::gentoo'`.
 * The complete build log is located at '/var/tmp/portage/app-admin/doas-6.8.2/temp/build.log'.
 * The ebuild environment file is located at '/var/tmp/portage/app-admin/doas-6.8.2/temp/environment'.
 * Working directory: '/var/tmp/portage/app-admin/doas-6.8.2/work/OpenDoas-6.8.2'
 * S: '/var/tmp/portage/app-admin/doas-6.8.2/work/OpenDoas-6.8.2'



----

cat /var/tmp/portage/app-admin/doas-6.8.2/temp/environment

declare -x ABI="amd64"
declare -x ABI_MIPS=""
declare -x ABI_S390=""
declare -x ABI_X86="64"
declare -x ADA_TARGET=""
declare -x ALSA_CARDS=""
declare -x AMDGPU_TARGETS=""
declare -x APACHE2_MODULES=""
declare -x APACHE2_MPMS=""
declare -x AR="x86_64-pc-linux-gnu-ar"
declare -x ARCH="amd64"
declare BDEPEND="app-alternatives/yacc "
declare -x BINPKG_FORMAT="gpkg"
declare -x BINPKG_GPG_SIGNING_BASE_COMMAND="/usr/bin/flock /run/lock/portage-binpkg-gpg.lock /usr/bin/gpg --sign --armor [PORTAGE_CONFIG]"
declare -x BINPKG_GPG_SIGNING_DIGEST="SHA512"
declare -x BINPKG_GPG_VERIFY_BASE_COMMAND="/usr/bin/gpg --verify --batch --no-tty --no-auto-check-trustdb --status-fd 2 [PORTAGE_CONFIG] [SIGNATURE]"
declare -x BINPKG_GPG_VERIFY_GPG_HOME="/etc/portage/gnupg"
declare -x BOOTSTRAP_USE="unicode pkg-config split-usr xml python_targets_python3_12 python_single_target_python3_12 multilib zstd cet"
declare -x CALLIGRA_FEATURES=""
declare -x CAMERAS=""
declare -x CBUILD="x86_64-pc-linux-gnu"
declare -x CC="x86_64-pc-linux-gnu-gcc"
declare -x CFLAGS="-march=native -O2 -pipe"
declare -x CFLAGS_amd64="-m64"
declare -x CFLAGS_default
declare -x CFLAGS_x32="-mx32"
declare -x CFLAGS_x86="-m32 -mfpmath=sse"
declare -x CHOST="x86_64-pc-linux-gnu"
declare -x CHOST_amd64="x86_64-pc-linux-gnu"
declare -x CHOST_default="x86_64-pc-linux-gnu"
declare -x CHOST_x32="x86_64-pc-linux-gnux32"
declare -x CHOST_x86="i686-pc-linux-gnu"
declare -x COLLECTD_PLUGINS=""
declare -x COMMON_FLAGS="-march=native -O2 -pipe"
declare -x CPU_FLAGS_ARM=""
declare -x CPU_FLAGS_PPC=""
declare -x CPU_FLAGS_X86=""
declare -x CTARGET_default="x86_64-pc-linux-gnu"
declare -x CURL_QUIC=""
declare -x CURL_SSL=""
declare -x CXXFLAGS="-march=native -O2 -pipe"
declare -x DEFAULT_ABI="amd64"
declare -x DEFINED_PHASES=" configure postinst"
declare DEPEND=$'pam? ( sys-libs/pam )\n\t!pam? ( virtual/libcrypt:= ) '
declare DESCRIPTION="Run commands as super/another user (alt sudo) (unofficial port from OpenBSD)"
declare -x DEVICE="/dev/nvme0n1"
declare -x DEVICE_SEPARATOR="p"
declare -x DIROPTIONS="-m0755"
declare -x EAPI="8"
declare -x EFI_SIZE="+1G"
declare -x ELIBC="glibc"
declare -x ENV_UNSET="CARGO_HOME DBUS_SESSION_BUS_ADDRESS DISPLAY GDK_PIXBUF_MODULE_FILE GOBIN GOPATH PERL5LIB PERL5OPT PERLPREFIX PERL_CORE PERL_MB_OPT PERL_MM_OPT XAUTHORITY XDG_CACHE_HOME XDG_CONFIG_HOME XDG_DATA_HOME XDG_RUNTIME_DIR XDG_STATE_HOME"
declare -- EPOCHREALTIME="1728815422.380740"
declare -- EPOCHSECONDS="1728815422"
declare -x EXEOPTIONS="-m0755"
declare -x FCFLAGS="-march=native -O2 -pipe"
declare -x FETCHCOMMAND_SSH="bash -c \"x=\\\${2#ssh://} ; host=\\\${x%%/*} ; port=\\\${host##*:} ; host=\\\${host%:*} ; [[ \\\${host} = \\\${port} ]] && port= ; exec rsync --rsh=\\\"ssh \\\${port:+-p\\\${port}} \\\${3}\\\" -avP \\\"\\\${host}:/\\\${x#*/}\\\" \\\"\\\$1\\\"\" rsync \"\${DISTDIR}/\${FILE}\" \"\${URI}\" \"\${PORTAGE_SSH_OPTS}\""
declare -x FFLAGS="-march=native -O2 -pipe"
declare -x FFTOOLS=""
declare -x GCC_SPECS=""
declare -x GNUMAKEFLAGS="--load-average 12 --output-sync=line"
declare -x GPG_VERIFY_GROUP_DROP="nogroup"
declare -x GPG_VERIFY_USER_DROP="nobody"
declare -x GPSD_PROTOCOLS=""
declare -x GRUB_PLATFORMS=""
declare -x GSETTINGS_BACKEND="dconf"
declare -x GUILE_SINGLE_TARGET=""
declare -x GUILE_TARGETS=""
declare HOMEPAGE="https://github.com/Duncaen/OpenDoas"
declare -x HOST="gentoo-laptop-msi-es"
declare -x HOSTS_DIR="/home/ubuntu/gentoo-installer/hosts"
declare -x HOST_SETUP="/home/ubuntu/gentoo-installer/hosts/gentoo-laptop-msi-es.props"
declare IDEPEND=""
declare -x INHERITED=" toolchain-funcs multilib"
declare -x INPUT_DEVICES=""
declare -x INSOPTIONS="-m0644"
declare IUSE="pam persist "
declare -x IUSE_EFFECTIVE="abi_x86_64 alpha amd64 amd64-linux arm arm64 arm64-macos elibc_Darwin elibc_SunOS elibc_bionic elibc_glibc elibc_mingw elibc_musl hppa kernel_Darwin kernel_SunOS kernel_linux loong m68k mips pam persist ppc ppc-macos ppc64 ppc64-linux prefix prefix-guest prefix-stack riscv s390 sparc x64-macos x64-solaris x86 x86-linux"
declare -x IUSE_IMPLICIT="abi_x86_64 prefix prefix-guest prefix-stack"
declare -x KERNEL="linux"
declare -x KERNEL_ABI="amd64"
declare -x KEYMAP="pt-latin9"
declare -x KEYWORDS="amd64 arm arm64 ~hppa ~loong ~ppc ppc64 ~riscv ~s390 ~sparc ~x86"
declare -x L10N=""
declare -x LANG="en_US.utf8"
declare -x LCD_DEVICES=""
declare -x LC_COLLATE="C"
declare -x LC_MESSAGES="C.utf8"
declare -x LDFLAGS="-Wl,-O1 -Wl,--as-needed -Wl,-z,pack-relative-relocs"
declare -x LDFLAGS_amd64="-m elf_x86_64"
declare -x LDFLAGS_default
declare -x LDFLAGS_x32="-m elf32_x86_64"
declare -x LDFLAGS_x86="-m elf_i386"
declare -x LESSCLOSE="/usr/bin/lesspipe %s %s"
declare -x LEX="flex"
declare -x LIBDIR_amd64="lib64"
declare -x LIBDIR_default="lib"
declare -x LIBDIR_x32="libx32"
declare -x LIBDIR_x86="lib"
declare -x LIBOPTIONS="-m0644"
declare -x LIBREOFFICE_EXTENSIONS=""
declare -x LICENSE="ISC"
declare -x LLVM_SLOT=""
declare -x LLVM_TARGETS=""
declare -x LUA_SINGLE_TARGET=""
declare -x LUA_TARGETS=""
declare -x MAIL="/var/mail/root"
declare -x MAKEOPTS="-j12"
declare -x MANPAGER="manpager"
declare -x MULTILIB_ABIS="amd64 x86"
declare -x MULTILIB_STRICT_DENY="64-bit.*shared object"
declare -x MULTILIB_STRICT_DIRS="/lib32 /lib /usr/lib32 /usr/lib /usr/kde/*/lib32 /usr/kde/*/lib /usr/qt/*/lib32 /usr/qt/*/lib /usr/X11R6/lib32 /usr/X11R6/lib"
declare -x MULTILIB_STRICT_EXEMPT="(perl5|gcc|binutils|eclipse-3|debug|portage|udev|systemd|clang|python-exec|llvm)"
declare -- MY_P="OpenDoas-6.8.2"
declare -- MY_PN="OpenDoas"
declare -x NGINX_MODULES_HTTP=""
declare -x NGINX_MODULES_MAIL=""
declare -x NGINX_MODULES_STREAM=""
declare -x OFFICE_IMPLEMENTATION=""
declare -x OPENMPI_FABRICS=""
declare -x OPENMPI_OFED_FEATURES=""
declare -x OPENMPI_RM=""
declare -x PASSWORD="greenpasture"
declare -x PATH="/usr/lib/portage/python3.12/ebuild-helpers/xattr:/usr/lib/portage/python3.12/ebuild-helpers:/usr/local/sbin:/usr/local/bin:/usr/bin:/opt/bin"
declare PDEPEND=""
declare -x PERL_FEATURES=""
declare -x PHP_TARGETS=""
declare -x PORTAGE_COMPRESSION_COMMAND="zstd -T12"
declare -a PORTAGE_DOCOMPRESS=([0]="/usr/share/doc" [1]="/usr/share/info" [2]="/usr/share/man")
declare -x PORTAGE_DOCOMPRESS_SIZE_LIMIT="128"
declare -a PORTAGE_DOCOMPRESS_SKIP=([0]="/usr/share/doc/doas-6.8.2/html")
declare -a PORTAGE_DOSTRIP=([0]="/")
declare -a PORTAGE_DOSTRIP_SKIP=()
declare -x PORTAGE_REPO_REVISIONS="{\"gentoo\": \"0d8f259ccbe3c67c9b9281980ed878a71788eddb\"}"
declare -x POSTGRES_TARGETS=""
declare -x PROFILE_ONLY_VARIABLES="ARCH ELIBC IUSE_IMPLICIT KERNEL USE_EXPAND_IMPLICIT USE_EXPAND_UNPREFIXED USE_EXPAND_VALUES_ARCH USE_EXPAND_VALUES_ELIBC USE_EXPAND_VALUES_KERNEL"
declare -- PROPERTIES=""
declare -x PYTHONDONTWRITEBYTECODE="1"
declare -x PYTHON_SINGLE_TARGET=""
declare -x PYTHON_TARGETS=""
declare -x QEMU_SOFTMMU_TARGETS=""
declare -x QEMU_USER_TARGETS=""
declare RDEPEND=$'pam? ( sys-libs/pam )\n\t!pam? ( virtual/libcrypt:= ) '
declare REPOSITORY
declare REQUIRED_USE=""
declare RESTRICT=""
declare -x RESUMECOMMAND_SSH="bash -c \"x=\\\${2#ssh://} ; host=\\\${x%%/*} ; port=\\\${host##*:} ; host=\\\${host%:*} ; [[ \\\${host} = \\\${port} ]] && port= ; exec rsync --rsh=\\\"ssh \\\${port:+-p\\\${port}} \\\${3}\\\" -avP \\\"\\\${host}:/\\\${x#*/}\\\" \\\"\\\$1\\\"\" rsync \"\${DISTDIR}/\${FILE}\" \"\${URI}\" \"\${PORTAGE_SSH_OPTS}\""
declare -x ROOT_SIZE="+128G"
declare -x RUBY_TARGETS=""
declare -x S="/var/tmp/portage/app-admin/doas-6.8.2/work/OpenDoas-6.8.2"
declare -x SANDBOX_DEBUG="0"
declare -x SANDBOX_DENY=""
declare -x SANDBOX_METHOD="any"
declare -x SANDBOX_PREDICT="/var/tmp/portage/app-admin/doas-6.8.2/homedir:/dev/crypto:/var/cache/man"
declare -x SANDBOX_READ="/:/var/tmp/portage"
declare -x SANDBOX_VERBOSE="1"
declare -x SANDBOX_WRITE=":/dev/console:/dev/fd:/dev/full:/dev/null:/dev/ptmx:/dev/pts/:/dev/pty:/dev/shm:/dev/tts:/dev/tty:/dev/vc/:/dev/zero:/proc/self/fd:/tmp/:/usr/lib/cf:/usr/lib/conftest:/usr/lib32/cf:/usr/lib32/conftest:/usr/lib64/cf:/usr/lib64/conftest:/usr/tmp/:/usr/tmp/cf:/usr/tmp/conftest:/var/tmp/:/var/tmp/portage:/var/tmp/portage/app-admin/doas-6.8.2/homedir/.bash_history"
declare -x SANE_BACKENDS=""
declare -x SCRIPT_ROOT_DIR="/home/ubuntu/gentoo-installer"
declare -x SHELL="/bin/bash"
declare -x SLOT="0"
declare -i SRANDOM="1960943306"
declare SRC_URI="https://github.com/Duncaen/OpenDoas/archive/v6.8.2.tar.gz -> OpenDoas-6.8.2.tar.gz"
declare -x STAGE_FILE="https://distfiles.gentoo.org/releases/amd64/autobuilds/20241006T144834Z/stage3-amd64-openrc-20241006T144834Z.tar.xz"
declare -x STEPS_DIR="/home/ubuntu/gentoo-installer/steps"
declare -x SUDO_COMMAND="/usr/bin/su"
declare -x SUDO_GID="1000"
declare -x SUDO_UID="1000"
declare -x SUDO_USER="ubuntu"
declare -x SWAP_SIZE="+8G"
declare -x SYMLINK_LIB="no"
declare -x TIMEZONE="Europe/Lisbon"
declare -x TWISTED_DISABLE_WRITING_OF_PLUGIN_CACHE="1"
declare -x USE="abi_x86_64 amd64 elibc_glibc kernel_linux pam persist"
declare -x USERLAND="GNU"
declare -x USE_EXPAND_IMPLICIT="ARCH ELIBC KERNEL"
declare -x USE_EXPAND_UNPREFIXED="ARCH"
declare -x USE_EXPAND_VALUES_ARCH="alpha amd64 amd64-linux arm arm64 arm64-macos hppa loong m68k mips ppc ppc64 ppc64-linux ppc-macos riscv s390 sparc x64-macos x64-solaris x86 x86-linux"
declare -x USE_EXPAND_VALUES_ELIBC="bionic Darwin glibc mingw musl SunOS"
declare -x USE_EXPAND_VALUES_KERNEL="Darwin linux SunOS"
declare -x UWSGI_PLUGINS=""
declare -x VIDEO_CARDS=""
declare -x VOICEMAIL_STORAGE=""
declare -x XDG_CURRENT_DESKTOP="ubuntu:GNOME"
declare -x XTABLES_ADDONS=""
declare -- _MULTILIB_ECLASS="1"
declare -- _TOOLCHAIN_FUNCS_ECLASS="1"
declare -x __E_DESTTREE="/usr"
declare -x __E_DOCDESTTREE=""
declare -x __E_EXEDESTTREE=""
declare -x __E_INSDESTTREE=""
declare -x ac_cv_c_undeclared_builtin_options="none needed"
declare -x enable_year2038="no"
declare -x gl_cv_compiler_check_decl_option="-Werror=implicit-function-declaration"
declare -x gl_cv_func_getcwd_path_max="yes"
__eapi6_src_install ()
{
	if [[ -f Makefile || -f GNUmakefile || -f makefile ]]; then
    	emake DESTDIR="${D}" install;
	fi;
	einstalldocs
}
__eapi6_src_prepare ()
{
	if ___is_indexed_array_var PATCHES; then
    	[[ ${#PATCHES[@]} -gt 0 ]] && eapply "${PATCHES[@]}";
	else
    	if [[ -n ${PATCHES} ]]; then
        	eapply ${PATCHES};
    	fi;
	fi;
	eapply_user
}
__eapi7_ver_compare ()
{
	local va=${1} vb=${2} a an al as ar b bn bl bs br re LC_ALL=C;
	re="^([0-9]+(\.[0-9]+)*)([a-z]?)((_(alpha|beta|pre|rc|p)[0-9]*)*)(-r[0-9]+)?$";
	[[ ${va} =~ ${re} ]] || die "${FUNCNAME}: invalid version: ${va}";
	an=${BASH_REMATCH[1]};
	al=${BASH_REMATCH[3]};
	as=${BASH_REMATCH[4]};
	ar=${BASH_REMATCH[7]};
	[[ ${vb} =~ ${re} ]] || die "${FUNCNAME}: invalid version: ${vb}";
	bn=${BASH_REMATCH[1]};
	bl=${BASH_REMATCH[3]};
	bs=${BASH_REMATCH[4]};
	br=${BASH_REMATCH[7]};
	__eapi7_ver_compare_int "${an%%.*}" "${bn%%.*}" || return;
	while [[ ${an} == *.* && ${bn} == *.* ]]; do
    	an=${an#*.};
    	bn=${bn#*.};
    	a=${an%%.*};
    	b=${bn%%.*};
    	if [[ ${a} == 0* || ${b} == 0* ]]; then
        	[[ ${a} =~ 0+$ ]] && a=${a%"${BASH_REMATCH[0]}"};
        	[[ ${b} =~ 0+$ ]] && b=${b%"${BASH_REMATCH[0]}"};
        	[[ ${a} > ${b} ]] && return 3;
        	[[ ${a} < ${b} ]] && return 1;
    	else
        	__eapi7_ver_compare_int "${a}" "${b}" || return;
    	fi;
	done;
	[[ ${an} == *.* ]] && return 3;
	[[ ${bn} == *.* ]] && return 1;
	[[ ${al} > ${bl} ]] && return 3;
	[[ ${al} < ${bl} ]] && return 1;
	as=${as#_}${as:+_};
	bs=${bs#_}${bs:+_};
	while [[ -n ${as} && -n ${bs} ]]; do
    	a=${as%%_*};
    	b=${bs%%_*};
    	if [[ ${a%%[0-9]*} == "${b%%[0-9]*}" ]]; then
        	__eapi7_ver_compare_int "${a##*[a-z]}" "${b##*[a-z]}" || return;
    	else
        	[[ ${a%%[0-9]*} == p ]] && return 3;
        	[[ ${b%%[0-9]*} == p ]] && return 1;
        	[[ ${a} > ${b} ]] && return 3 || return 1;
    	fi;
    	as=${as#*_};
    	bs=${bs#*_};
	done;
	if [[ -n ${as} ]]; then
    	[[ ${as} == p[_0-9]* ]] && return 3 || return 1;
	else
    	if [[ -n ${bs} ]]; then
        	[[ ${bs} == p[_0-9]* ]] && return 1 || return 3;
    	fi;
	fi;
	__eapi7_ver_compare_int "${ar#-r}" "${br#-r}" || return;
	return 2
}
__eapi7_ver_compare_int ()
{
	local a=$1 b=$2 d=$(( ${#1}-${#2} ));
	if [[ ${d} -gt 0 ]]; then
    	printf -v b "%0${d}d%s" 0 "${b}";
	else
    	if [[ ${d} -lt 0 ]]; then
        	printf -v a "%0$(( -d ))d%s" 0 "${a}";
    	fi;
	fi;
	[[ ${a} > ${b} ]] && return 3;
	[[ ${a} == "${b}" ]]
}
__eapi7_ver_parse_range ()
{
	local range=${1};
	local max=${2};
	[[ ${range} == [0-9]* ]] || die "${FUNCNAME}: range must start with a number";
	start=${range%-*};
	[[ ${range} == *-* ]] && end=${range#*-} || end=${start};
	if [[ -n ${end} ]]; then
    	[[ ${start} -le ${end} ]] || die "${FUNCNAME}: end of range must be >= start";
    	[[ ${end} -le ${max} ]] || end=${max};
	else
    	end=${max};
	fi
}
__eapi7_ver_split ()
{
	local v=${1} LC_ALL=C;
	comp=();
	local s c;
	while [[ -n ${v} ]]; do
    	s=${v%%[a-zA-Z0-9]*};
    	v=${v:${#s}};
    	[[ ${v} == [0-9]* ]] && c=${v%%[^0-9]*} || c=${v%%[^a-zA-Z]*};
    	v=${v:${#c}};
    	comp+=("${s}" "${c}");
	done
}
__eapi8_src_prepare ()
{
	local f;
	if ___is_indexed_array_var PATCHES; then
    	[[ ${#PATCHES[@]} -gt 0 ]] && eapply -- "${PATCHES[@]}";
	else
    	if [[ -n ${PATCHES} ]]; then
        	eapply -- ${PATCHES};
    	fi;
	fi;
	eapply_user
}
_clang_fullversion ()
{
	local ver="$1";
	shift;
	set -- $($(tc-getCPP "$@") -E -P - <<< "__clang_major__ __clang_minor__ __clang_patchlevel__");
	eval echo "${ver}"
}
_gcc-install-dir ()
{
	echo "$(LC_ALL=C $(tc-getCC) -print-search-dirs 2> /dev/null | awk '$1=="install:" {print $2}')"
}
_gcc-specs-directive_raw ()
{
	local cc=$(tc-getCC);
	local specfiles=$(LC_ALL=C ${cc} -v 2>&1 | awk '$1=="Reading" {print $NF}');
	${cc} -dumpspecs 2> /dev/null | cat - ${specfiles} | awk -v directive=$1 'BEGIN	{ pspec=""; spec=""; outside=1 }
$1=="*"directive":"  { pspec=spec; spec=""; outside=0; next }
	outside || NF==0 || ( substr($1,1,1)=="*" && substr($1,length($1),1)==":" ) { outside=1; next }
	spec=="" && substr($0,1,1)=="+" { spec=pspec " " substr($0,2); next }
	{ spec=spec $0 }
END	{ print spec }';
	return 0
}
_gcc-specs-exists ()
{
	[[ -f $(_gcc-install-dir)/$1 ]]
}
_gcc_fullversion ()
{
	local ver="$1";
	shift;
	set -- $($(tc-getCPP "$@") -E -P - <<< "__GNUC__ __GNUC_MINOR__ __GNUC_PATCHLEVEL__");
	eval echo "${ver}"
}
_tc-getPROG ()
{
	local tuple=$1;
	local v var vars=$2;
	local prog=($3);
	var=${vars%% *};
	for v in ${vars};
	do
    	if [[ -n ${!v} ]]; then
        	export ${var}="${!v}";
        	echo "${!v}";
        	return 0;
    	fi;
	done;
	local search=;
	[[ -n $4 ]] && search=$(type -p $4-${prog[0]});
	[[ -z ${search} && -n ${!tuple} ]] && search=$(type -p ${!tuple}-${prog[0]});
	[[ -n ${search} ]] && prog[0]=${search##*/};
	export ${var}="${prog[*]}";
	echo "${!var}"
}
_tc-has-openmp ()
{
	local base="${T}/test-tc-openmp";
	cat <<-EOF > "${base}.c"
#include <omp.h>
int main(void) {
int nthreads, tid, ret = 0;
#pragma omp parallel private(nthreads, tid)
{
tid = omp_get_thread_num();
nthreads = omp_get_num_threads();
ret += tid + nthreads;
}
return ret;
}
EOF

	$(tc-getCC "$@") -fopenmp "${base}.c" -o "${base}" >&/dev/null;
	local ret=$?;
	rm -f "${base}"*;
	return ${ret}
}
clang-fullversion ()
{
	_clang_fullversion '$1.$2.$3' "$@"
}
clang-major-version ()
{
	_clang_fullversion '$1' "$@"
}
clang-micro-version ()
{
	_clang_fullversion '$3' "$@"
}
clang-minor-version ()
{
	_clang_fullversion '$2' "$@"
}
clang-version ()
{
	_clang_fullversion '$1.$2' "$@"
}
eapply ()
{
	local failed patch_cmd=patch;
	local -x LC_COLLATE=POSIX;
	type -P gpatch > /dev/null && patch_cmd=gpatch;
	function _eapply_patch ()
	{
    	local f=${1};
    	local prefix=${2};
    	ebegin "${prefix:-Applying }${f##*/}";
    	local all_opts=(-p1 -f -g0 --no-backup-if-mismatch "${patch_options[@]}");
    	if ${patch_cmd} "${all_opts[@]}" --dry-run -s -F0 < "${f}" &> /dev/null; then
        	all_opts+=(-s -F0);
    	fi;
    	${patch_cmd} "${all_opts[@]}" < "${f}";
    	failed=${?};
    	if ! eend "${failed}"; then
        	__helpers_die "patch -p1 ${patch_options[*]} failed with ${f}";
    	fi
	};
	local patch_options=() files=();
	local i found_doublehyphen;
	for ((i = 1; i <= ${#@}; ++i ))
	do
    	if [[ ${@:i:1} == -- ]]; then
        	patch_options=("${@:1:i-1}");
        	files=("${@:i+1}");
        	found_doublehyphen=1;
        	break;
    	fi;
	done;
	if [[ -z ${found_doublehyphen} ]]; then
    	for ((i = 1; i <= ${#@}; ++i ))
    	do
        	if [[ ${@:i:1} != -* ]]; then
            	patch_options=("${@:1:i-1}");
            	files=("${@:i}");
            	break;
        	fi;
    	done;
    	for i in "${files[@]}";
    	do
        	if [[ ${i} == -* ]]; then
            	die "eapply: all options must be passed before non-options";
        	fi;
    	done;
	fi;
	if [[ ${#files[@]} -eq 0 ]]; then
    	die "eapply: no files specified";
	fi;
	local f;
	for f in "${files[@]}";
	do
    	if [[ -d ${f} ]]; then
        	function _eapply_get_files ()
        	{
            	local LC_ALL=POSIX;
            	local prev_shopt=$(shopt -p nullglob);
            	shopt -s nullglob;
            	local f;
            	for f in "${1}"/*;
            	do
                	if [[ ${f} == *.diff || ${f} == *.patch ]]; then
                    	files+=("${f}");
                	fi;
            	done;
            	${prev_shopt}
        	};
        	local files=();
        	_eapply_get_files "${f}";
        	[[ ${#files[@]} -eq 0 ]] && die "No *.{patch,diff} files in directory ${f}";
        	einfo "Applying patches from ${f} ...";
        	local f2;
        	for f2 in "${files[@]}";
        	do
            	_eapply_patch "${f2}" '  ';
            	[[ ${failed} -ne 0 ]] && return "${failed}";
        	done;
    	else
        	_eapply_patch "${f}";
        	[[ ${failed} -ne 0 ]] && return "${failed}";
    	fi;
	done;
	return 0
}
eapply_user ()
{
	[[ ${EBUILD_PHASE} == prepare ]] || die "eapply_user() called during invalid phase: ${EBUILD_PHASE}";
	local tagfile=${T}/.portage_user_patches_applied;
	[[ -f ${tagfile} ]] && return;
	>> "${tagfile}";
	local basedir=${PORTAGE_CONFIGROOT%/}/etc/portage/patches;
	local columns=${COLUMNS:-0};
	[[ ${columns} == 0 ]] && columns=$(set -- $( ( stty size < /dev/tty ) 2> /dev/null || echo 24 80); echo $2);
	(( columns > 0 )) || (( columns = 80 ));
	local applied d f;
	local -A _eapply_user_patches;
	local prev_shopt=$(shopt -p nullglob);
	shopt -s nullglob;
	for d in "${basedir}"/${CATEGORY}/{${P}-${PR},${P},${PN}}{:${SLOT%/*},};
	do
    	for f in "${d}"/*;
    	do
        	if [[ ( ${f} == *.diff || ${f} == *.patch ) && -z ${_eapply_user_patches[${f##*/}]} ]]; then
            	_eapply_user_patches[${f##*/}]=${f};
        	fi;
    	done;
	done;
	if [[ ${#_eapply_user_patches[@]} -gt 0 ]]; then
    	while read -r -d '' f; do
        	f=${_eapply_user_patches[${f}]};
        	if [[ -s ${f} ]]; then
            	if [[ -z ${applied} ]]; then
                	einfo "${PORTAGE_COLOR_INFO}$(for ((column = 0; column < ${columns} - 3; column++))
do
	echo -n =;
done)${PORTAGE_COLOR_NORMAL}";
                	einfo "Applying user patches from ${basedir} ...";
            	fi;
            	eapply "${f}";
            	applied=1;
        	fi;
    	done < <(printf -- '%s\0' "${!_eapply_user_patches[@]}" | LC_ALL=C sort -z);
	fi;
	${prev_shopt};
	if [[ -n ${applied} ]]; then
    	einfo "User patches applied.";
    	einfo "${PORTAGE_COLOR_INFO}$(for ((column = 0; column < ${columns} - 3; column++))
do
	echo -n =;
done)${PORTAGE_COLOR_NORMAL}";
	fi
}
econf_build ()
{
	local CBUILD=${CBUILD:-${CHOST}};
	function econf_env ()
	{
    	CHOST=${CBUILD} econf "$@"
	};
	tc-env_build econf_env "$@"
}
einstalldocs ()
{
	( if [[ $(declare -p DOCS 2> /dev/null) != *=* ]]; then
    	local d;
    	for d in README* ChangeLog AUTHORS NEWS TODO CHANGES THANKS BUGS FAQ CREDITS CHANGELOG;
    	do
        	[[ -f ${d} && -s ${d} ]] && docinto / && dodoc "${d}";
    	done;
	else
    	if ___is_indexed_array_var DOCS; then
        	[[ ${#DOCS[@]} -gt 0 ]] && docinto / && dodoc -r "${DOCS[@]}";
    	else
        	[[ -n ${DOCS} ]] && docinto / && dodoc -r ${DOCS};
    	fi;
	fi );
	( if ___is_indexed_array_var HTML_DOCS; then
    	[[ ${#HTML_DOCS[@]} -gt 0 ]] && docinto html && dodoc -r "${HTML_DOCS[@]}";
	else
    	[[ -n ${HTML_DOCS} ]] && docinto html && dodoc -r ${HTML_DOCS};
	fi )
}
gcc-fullversion ()
{
	_gcc_fullversion '$1.$2.$3' "$@"
}
gcc-major-version ()
{
	_gcc_fullversion '$1' "$@"
}
gcc-micro-version ()
{
	_gcc_fullversion '$3' "$@"
}
gcc-minor-version ()
{
	_gcc_fullversion '$2' "$@"
}
gcc-specs-directive ()
{
	local directive subdname subdirective;
	directive="$(_gcc-specs-directive_raw $1)";
	while [[ ${directive} == *%\(*\)* ]]; do
    	subdname=${directive/*%\(};
    	subdname=${subdname/\)*};
    	subdirective="$(_gcc-specs-directive_raw ${subdname})";
    	directive="${directive//\%(${subdname})/${subdirective}}";
	done;
	echo "${directive}";
	return 0
}
gcc-specs-nostrict ()
{
	local directive;
	directive=$(gcc-specs-directive cc1);
	[[ "${directive/\{!fstrict-overflow:}" != "${directive}" ]]
}
gcc-specs-now ()
{
	local directive;
	directive=$(gcc-specs-directive link_command);
	[[ "${directive/\{!nonow:}" != "${directive}" ]]
}
gcc-specs-pie ()
{
	local directive;
	directive=$(gcc-specs-directive cc1);
	[[ "${directive/\{!nopie:}" != "${directive}" ]]
}
gcc-specs-relro ()
{
	local directive;
	directive=$(gcc-specs-directive link_command);
	[[ "${directive/\{!norelro:}" != "${directive}" ]]
}
gcc-specs-ssp ()
{
	local directive;
	directive=$(gcc-specs-directive cc1);
	[[ "${directive/\{!fno-stack-protector:}" != "${directive}" ]]
}
gcc-specs-ssp-to-all ()
{
	local directive;
	directive=$(gcc-specs-directive cc1);
	[[ "${directive/\{!fno-stack-protector-all:}" != "${directive}" ]]
}
gcc-specs-stack-check ()
{
	local directive;
	directive=$(gcc-specs-directive cc1);
	[[ "${directive/\{!fno-stack-check:}" != "${directive}" ]]
}
gcc-version ()
{
	_gcc_fullversion '$1.$2' "$@"
}
gen_usr_ldscript ()
{
	ewarn "${FUNCNAME}: Please migrate to usr-ldscript.eclass";
	local lib libdir=$(get_libdir) output_format="" auto=false suffix=$(get_libname);
	tc-is-static-only && return;
	use prefix && return;
	if [[ $(type -t multilib_is_native_abi) == "function" ]]; then
    	multilib_is_native_abi || return 0;
	fi;
	case ${CTARGET:-${CHOST}} in
    	*-darwin*)

    	;;
    	*-android*)
        	return 0
    	;;
    	*linux*)
        	use prefix && return 0
    	;;
    	*)
        	return 0
    	;;
	esac;
	dodir /usr/${libdir};
	if [[ $1 == "-a" ]]; then
    	auto=true;
    	shift;
    	dodir /${libdir};
	fi;
	local flags=(${CFLAGS} ${LDFLAGS} -Wl,--verbose);
	if $(tc-getLD) --version | grep -q 'GNU gold'; then
    	local d="${T}/bfd-linker";
    	mkdir -p "${d}";
    	ln -sf $(type -P ${CHOST}-ld.bfd) "${d}"/ld;
    	flags+=(-B"${d}");
	fi;
	output_format=$($(tc-getCC) "${flags[@]}" 2>&1 | sed -n 's/^OUTPUT_FORMAT("\([^"]*\)",.*/\1/p');
	[[ -n ${output_format} ]] && output_format="OUTPUT_FORMAT ( ${output_format} )";
	for lib in "$@";
	do
    	local tlib;
    	if ${auto}; then
        	lib="lib${lib}${suffix}";
    	else
        	[[ -r ${ED}/${libdir}/${lib} ]] || continue;
    	fi;
    	case ${CTARGET:-${CHOST}} in
        	*-darwin*)
            	if ${auto}; then
                	tlib=$(scanmacho -qF'%S#F' "${ED}"/usr/${libdir}/${lib});
            	else
                	tlib=$(scanmacho -qF'%S#F' "${ED}"/${libdir}/${lib});
            	fi;
            	[[ -z ${tlib} ]] && die "unable to read install_name from ${lib}";
            	tlib=${tlib##*/};
            	if ${auto}; then
                	mv "${ED}"/usr/${libdir}/${lib%${suffix}}.*${suffix#.} "${ED}"/${libdir}/ || die;
                	if [[ ${tlib} != ${lib%${suffix}}.*${suffix#.} ]]; then
                    	mv "${ED}"/usr/${libdir}/${tlib%${suffix}}.*${suffix#.} "${ED}"/${libdir}/ || die;
                	fi;
                	rm -f "${ED}"/${libdir}/${lib};
            	fi;
            	if [[ ! -w "${ED}/${libdir}/${tlib}" ]]; then
                	chmod u+w "${ED}${libdir}/${tlib}";
                	local nowrite=yes;
            	fi;
            	install_name_tool -id "${EPREFIX}"/${libdir}/${tlib} "${ED}"/${libdir}/${tlib} || die "install_name_tool failed";
            	[[ -n ${nowrite} ]] && chmod u-w "${ED}${libdir}/${tlib}";
            	pushd "${ED}/usr/${libdir}" > /dev/null;
            	ln -snf "../../${libdir}/${tlib}" "${lib}";
            	popd > /dev/null
        	;;
        	*)
            	if ${auto}; then
                	tlib=$(scanelf -qF'%S#F' "${ED}"/usr/${libdir}/${lib});
                	[[ -z ${tlib} ]] && die "unable to read SONAME from ${lib}";
                	mv "${ED}"/usr/${libdir}/${lib}* "${ED}"/${libdir}/ || die;
                	if [[ ${tlib} != ${lib}* ]]; then
                    	mv "${ED}"/usr/${libdir}/${tlib}* "${ED}"/${libdir}/ || die;
                	fi;
                	rm -f "${ED}"/${libdir}/${lib};
            	else
                	tlib=${lib};
            	fi;
            	cat > "${ED}/usr/${libdir}/${lib}" <<-END_LDSCRIPT
/* GNU ld script
   Since Gentoo has critical dynamic libraries in /lib, and the static versions
   in /usr/lib, we need to have a "fake" dynamic lib in /usr/lib, otherwise we
   run into linking problems.  This "fake" dynamic lib is a linker script that
   redirects the linker to the real lib.  And yes, this works in the cross-
   compiling scenario as the sysroot-ed linker will prepend the real path.

   See bug https://bugs.gentoo.org/4411 for more info.
 */
${output_format}
GROUP ( ${EPREFIX}/${libdir}/${tlib} )
END_LDSCRIPT

        	;;
    	esac
    	fperms a+x "/usr/${libdir}/${lib}" || die "could not change perms on ${lib}";
	done
}
get_abi_CFLAGS ()
{
	get_abi_var CFLAGS "$@"
}
get_abi_CHOST ()
{
	get_abi_var CHOST "$@"
}
get_abi_CTARGET ()
{
	get_abi_var CTARGET "$@"
}
get_abi_FAKE_TARGETS ()
{
	get_abi_var FAKE_TARGETS "$@"
}
get_abi_LDFLAGS ()
{
	get_abi_var LDFLAGS "$@"
}
get_abi_LIBDIR ()
{
	get_abi_var LIBDIR "$@"
}
get_abi_var ()
{
	local flag=$1;
	local abi=${2:-${ABI:-${DEFAULT_ABI:-default}}};
	local var="${flag}_${abi}";
	echo ${!var}
}
get_all_abis ()
{
	local x order="" mvar dvar;
	mvar="MULTILIB_ABIS";
	dvar="DEFAULT_ABI";
	if [[ -n $1 ]]; then
    	mvar="$1_${mvar}";
    	dvar="$1_${dvar}";
	fi;
	if [[ -z ${!mvar} ]]; then
    	echo "default";
    	return 0;
	fi;
	for x in ${!mvar};
	do
    	if [[ ${x} != ${!dvar} ]]; then
        	order="${order:+${order} }${x}";
    	fi;
	done;
	order="${order:+${order} }${!dvar}";
	echo ${order};
	return 0
}
get_all_libdirs ()
{
	local libdirs abi;
	for abi in ${MULTILIB_ABIS};
	do
    	libdirs+=" $(get_abi_LIBDIR ${abi})";
	done;
	[[ " ${libdirs} " != *" lib "* ]] && libdirs+=" lib";
	echo "${libdirs}"
}
get_exeext ()
{
	case ${CHOST} in
    	mingw* | *-mingw*)
        	echo ".exe"
    	;;
	esac
}
get_install_abis ()
{
	local x order="";
	if [[ -z ${MULTILIB_ABIS} ]]; then
    	echo "default";
    	return 0;
	fi;
	if [[ ${EMULTILIB_PKG} == "true" ]]; then
    	for x in ${MULTILIB_ABIS};
    	do
        	if [[ ${x} != "${DEFAULT_ABI}" ]]; then
            	has ${x} ${ABI_DENY} || order="${order} ${x}";
        	fi;
    	done;
    	has ${DEFAULT_ABI} ${ABI_DENY} || order="${order} ${DEFAULT_ABI}";
    	if [[ -n ${ABI_ALLOW} ]]; then
        	local ordera="";
        	for x in ${order};
        	do
            	if has ${x} ${ABI_ALLOW}; then
                	ordera="${ordera} ${x}";
            	fi;
        	done;
        	order=${ordera};
    	fi;
	else
    	order=${DEFAULT_ABI};
	fi;
	if [[ -z ${order} ]]; then
    	die "The ABI list is empty.  Are you using a proper multilib profile?  Perhaps your USE flags or MULTILIB_ABIS are too restrictive for this package.";
	fi;
	echo ${order};
	return 0
}
get_libdir ()
{
	local libdir_var="LIBDIR_${ABI}";
	local libdir="lib";
	[[ -n ${ABI} && -n ${!libdir_var} ]] && libdir=${!libdir_var};
	echo "${libdir}"
}
get_libname ()
{
	local libname;
	local ver=$1;
	case ${CHOST} in
    	mingw* | *-mingw*)
        	libname="dll"
    	;;
    	*-darwin*)
        	libname="dylib"
    	;;
    	*)
        	libname="so"
    	;;
	esac;
	if [[ -z $* ]]; then
    	echo ".${libname}";
	else
    	for ver in "$@";
    	do
        	case ${CHOST} in
            	*-darwin*)
                	echo ".${ver}.${libname}"
            	;;
            	*)
                	echo ".${libname}.${ver}"
            	;;
        	esac;
    	done;
	fi
}
get_modname ()
{
	local modname;
	local ver=$1;
	case ${CHOST} in
    	*-darwin*)
        	modname="bundle"
    	;;
    	*)
        	modname="so"
    	;;
	esac;
	echo ".${modname}"
}
has_multilib_profile ()
{
	[ -n "${MULTILIB_ABIS}" -a "${MULTILIB_ABIS}" != "${MULTILIB_ABIS/ /}" ]
}
in_iuse ()
{
	local use=${1};
	if [[ -z "${use}" ]]; then
    	echo "!!! in_iuse() called without a parameter." 1>&2;
    	echo "!!! in_iuse <USEFLAG>" 1>&2;
    	die "in_iuse() called without a parameter";
	fi;
	local liuse=(${IUSE_EFFECTIVE});
	has "${use}" "${liuse[@]#[+-]}"
}
is_final_abi ()
{
	has_multilib_profile || return 0;
	set -- $(get_install_abis);
	local LAST_ABI=$#;
	[[ ${!LAST_ABI} == ${ABI} ]]
}
multilib_env ()
{
	local CTARGET=${1:-${CTARGET}};
	local cpu=${CTARGET%%*-};
	if [[ ${CTARGET} = *-musl* ]]; then
    	: "${MULTILIB_ABIS=default}";
    	: "${DEFAULT_ABI=default}";
    	export MULTILIB_ABIS DEFAULT_ABI;
    	return;
	fi;
	case ${cpu} in
    	aarch64*)
        	export CFLAGS_arm=${CFLAGS_arm-};
        	case ${cpu} in
            	aarch64*be)
                	export CHOST_arm="armv8b-${CTARGET#*-}"
            	;;
            	*)
                	export CHOST_arm="armv8l-${CTARGET#*-}"
            	;;
        	esac;
        	CHOST_arm=${CHOST_arm/%-gnu/-gnueabi};
        	export CTARGET_arm=${CHOST_arm};
        	export LIBDIR_arm="lib";
        	export CFLAGS_arm64=${CFLAGS_arm64-};
        	export CHOST_arm64=${CTARGET};
        	export CTARGET_arm64=${CHOST_arm64};
        	export LIBDIR_arm64="lib64";
        	: "${MULTILIB_ABIS=arm64}";
        	: "${DEFAULT_ABI=arm64}"
    	;;
    	x86_64*)
        	export CFLAGS_x86=${CFLAGS_x86--m32};
        	export CHOST_x86=${CTARGET/x86_64/i686};
        	CHOST_x86=${CHOST_x86/%-gnux32/-gnu};
        	export CTARGET_x86=${CHOST_x86};
        	if [[ ${SYMLINK_LIB} == "yes" ]]; then
            	export LIBDIR_x86="lib32";
        	else
            	export LIBDIR_x86="lib";
        	fi;
        	export CFLAGS_amd64=${CFLAGS_amd64--m64};
        	export CHOST_amd64=${CTARGET/%-gnux32/-gnu};
        	export CTARGET_amd64=${CHOST_amd64};
        	export LIBDIR_amd64="lib64";
        	export CFLAGS_x32=${CFLAGS_x32--mx32};
        	export CHOST_x32=${CTARGET/%-gnu/-gnux32};
        	export CTARGET_x32=${CHOST_x32};
        	export LIBDIR_x32="libx32";
        	case ${CTARGET} in
            	*-gnux32)
                	: "${MULTILIB_ABIS=x32 amd64 x86}";
                	: "${DEFAULT_ABI=x32}"
            	;;
            	*)
                	: "${MULTILIB_ABIS=amd64 x86}";
                	: "${DEFAULT_ABI=amd64}"
            	;;
        	esac
    	;;
    	loongarch64*)
        	export CFLAGS_lp64d=${CFLAGS_lp64d--mabi=lp64d};
        	export CHOST_lp64d=${CTARGET};
        	export CTARGET_lp64d=${CTARGET};
        	export LIBDIR_lp64d=${LIBDIR_lp64d-lib64};
        	: "${MULTILIB_ABIS=lp64d}";
        	: "${DEFAULT_ABI=lp64d}"
    	;;
    	mips64* | mipsisa64*)
        	export CFLAGS_o32=${CFLAGS_o32--mabi=32};
        	export CHOST_o32=${CTARGET/mips64/mips};
        	export CHOST_o32=${CHOST_o32/mipsisa64/mipsisa32};
        	export CTARGET_o32=${CHOST_o32};
        	export LIBDIR_o32="lib";
        	export CFLAGS_n32=${CFLAGS_n32--mabi=n32};
        	export CHOST_n32=${CTARGET};
        	export CTARGET_n32=${CHOST_n32};
        	export LIBDIR_n32="lib32";
        	export CFLAGS_n64=${CFLAGS_n64--mabi=64};
        	export CHOST_n64=${CTARGET};
        	export CTARGET_n64=${CHOST_n64};
        	export LIBDIR_n64="lib64";
        	: "${MULTILIB_ABIS=n64 n32 o32}";
        	: "${DEFAULT_ABI=n32}"
    	;;
    	powerpc64*)
        	export CFLAGS_ppc=${CFLAGS_ppc--m32};
        	export CHOST_ppc=${CTARGET/powerpc64/powerpc};
        	export CTARGET_ppc=${CHOST_ppc};
        	export LIBDIR_ppc="lib";
        	export CFLAGS_ppc64=${CFLAGS_ppc64--m64};
        	export CHOST_ppc64=${CTARGET};
        	export CTARGET_ppc64=${CHOST_ppc64};
        	export LIBDIR_ppc64="lib64";
        	: "${MULTILIB_ABIS=ppc64 ppc}";
        	: "${DEFAULT_ABI=ppc64}"
    	;;
    	riscv64*)
        	: "${MULTILIB_ABIS=lp64d lp64 ilp32d ilp32}";
        	: "${DEFAULT_ABI=lp64d}";
        	local _libdir_riscvdefaultabi_variable="LIBDIR_${DEFAULT_ABI}";
        	local _libdir_riscvdefaultabi=${!_libdir_riscvdefaultabi_variable};
        	export ${_libdir_riscvdefaultabi_variable}=${_libdir_riscvdefaultabi:-lib64};
        	export CFLAGS_lp64d=${CFLAGS_lp64d--mabi=lp64d -march=rv64gc};
        	export CHOST_lp64d=${CTARGET};
        	export CTARGET_lp64d=${CTARGET};
        	export LIBDIR_lp64d=${LIBDIR_lp64d-lib64/lp64d};
        	export CFLAGS_lp64=${CFLAGS_lp64--mabi=lp64 -march=rv64imac};
        	export CHOST_lp64=${CTARGET};
        	export CTARGET_lp64=${CTARGET};
        	export LIBDIR_lp64=${LIBDIR_lp64-lib64/lp64};
        	export CFLAGS_ilp32d=${CFLAGS_ilp32d--mabi=ilp32d -march=rv32imafdc};
        	export CHOST_ilp32d=${CTARGET/riscv64/riscv32};
        	export CTARGET_ilp32d=${CTARGET/riscv64/riscv32};
        	export LIBDIR_ilp32d=${LIBDIR_ilp32d-lib32/ilp32d};
        	export CFLAGS_ilp32=${CFLAGS_ilp32--mabi=ilp32 -march=rv32imac};
        	export CHOST_ilp32=${CTARGET/riscv64/riscv32};
        	export CTARGET_ilp32=${CTARGET/riscv64/riscv32};
        	export LIBDIR_ilp32=${LIBDIR_ilp32-lib32/ilp32}
    	;;
    	riscv32*)
        	: "${MULTILIB_ABIS=ilp32d ilp32}";
        	: "${DEFAULT_ABI=ilp32d}";
        	local _libdir_riscvdefaultabi_variable="LIBDIR_${DEFAULT_ABI}";
        	local _libdir_riscvdefaultabi=${!_libdir_riscvdefaultabi_variable};
        	export ${_libdir_riscvdefaultabi_variable}=${_libdir_riscvdefaultabi:-lib};
        	export CFLAGS_ilp32d=${CFLAGS_ilp32d--mabi=ilp32d -march=rv32imafdc};
        	export CHOST_ilp32d=${CTARGET};
        	export CTARGET_ilp32d=${CTARGET};
        	export LIBDIR_ilp32d=${LIBDIR_ilp32d-lib32/ilp32d};
        	export CFLAGS_ilp32=${CFLAGS_ilp32--mabi=ilp32 -march=rv32imac};
        	export CHOST_ilp32=${CTARGET};
        	export CTARGET_ilp32=${CTARGET};
        	export LIBDIR_ilp32=${LIBDIR_ilp32-lib32/ilp32}
    	;;
    	s390x*)
        	export CFLAGS_s390=${CFLAGS_s390--m31};
        	export CHOST_s390=${CTARGET/s390x/s390};
        	export CTARGET_s390=${CHOST_s390};
        	export LIBDIR_s390="lib";
        	export CFLAGS_s390x=${CFLAGS_s390x--m64};
        	export CHOST_s390x=${CTARGET};
        	export CTARGET_s390x=${CHOST_s390x};
        	export LIBDIR_s390x="lib64";
        	: "${MULTILIB_ABIS=s390x s390}";
        	: "${DEFAULT_ABI=s390x}"
    	;;
    	sparc64*)
        	export CFLAGS_sparc32=${CFLAGS_sparc32--m32};
        	export CHOST_sparc32=${CTARGET/sparc64/sparc};
        	export CTARGET_sparc32=${CHOST_sparc32};
        	export LIBDIR_sparc32="lib";
        	export CFLAGS_sparc64=${CFLAGS_sparc64--m64};
        	export CHOST_sparc64=${CTARGET};
        	export CTARGET_sparc64=${CHOST_sparc64};
        	export LIBDIR_sparc64="lib64";
        	: "${MULTILIB_ABIS=sparc64 sparc32}";
        	: "${DEFAULT_ABI=sparc64}"
    	;;
    	*)
        	: "${MULTILIB_ABIS=default}";
        	: "${DEFAULT_ABI=default}"
    	;;
	esac;
	export MULTILIB_ABIS DEFAULT_ABI
}
multilib_toolchain_setup ()
{
	local v vv;
	export ABI=$1;
	local save_restore_variables=(CBUILD CHOST AR CC CXX F77 FC LD NM OBJCOPY OBJDUMP PKG_CONFIG RANLIB READELF STRINGS STRIP PKG_CONFIG_LIBDIR PKG_CONFIG_PATH PKG_CONFIG_SYSTEM_INCLUDE_PATH PKG_CONFIG_SYSTEM_LIBRARY_PATH);
	if [[ ${_DEFAULT_ABI_SAVED} == "true" ]]; then
    	for v in "${save_restore_variables[@]}";
    	do
        	vv="_abi_saved_${v}";
        	[[ ${!vv+set} == "set" ]] && export ${v}="${!vv}" || unset ${v};
        	unset ${vv};
    	done;
    	unset _DEFAULT_ABI_SAVED;
	fi;
	if [[ ${ABI} != ${DEFAULT_ABI} ]]; then
    	for v in "${save_restore_variables[@]}";
    	do
        	vv="_abi_saved_${v}";
        	[[ ${!v+set} == "set" ]] && export ${vv}="${!v}" || unset ${vv};
    	done;
    	export _DEFAULT_ABI_SAVED="true";
    	if [[ ${CBUILD} == "${CHOST}" ]]; then
        	export CBUILD=$(get_abi_CHOST $1);
    	fi;
    	export CHOST=$(get_abi_CHOST ${DEFAULT_ABI});
    	export AR="$(tc-getAR)";
    	export CC="$(tc-getCC) $(get_abi_CFLAGS)";
    	export CXX="$(tc-getCXX) $(get_abi_CFLAGS)";
    	export F77="$(tc-getF77) $(get_abi_CFLAGS)";
    	export FC="$(tc-getFC) $(get_abi_CFLAGS)";
    	export LD="$(tc-getLD) $(get_abi_LDFLAGS)";
    	export NM="$(tc-getNM)";
    	export OBJCOPY="$(tc-getOBJCOPY)";
    	export OBJDUMP="$(tc-getOBJDUMP)";
    	export PKG_CONFIG="$(tc-getPKG_CONFIG)";
    	export RANLIB="$(tc-getRANLIB)";
    	export READELF="$(tc-getREADELF)";
    	export STRINGS="$(tc-getSTRINGS)";
    	export STRIP="$(tc-getSTRIP)";
    	export CHOST=$(get_abi_CHOST $1);
    	export PKG_CONFIG_LIBDIR=${EPREFIX}/usr/$(get_libdir)/pkgconfig;
    	export PKG_CONFIG_PATH=${EPREFIX}/usr/share/pkgconfig;
    	export PKG_CONFIG_SYSTEM_INCLUDE_PATH=${EPREFIX}/usr/include;
    	export PKG_CONFIG_SYSTEM_LIBRARY_PATH=${EPREFIX}/$(get_libdir):${EPREFIX}/usr/$(get_libdir);
	fi
}
number_abis ()
{
	set -- `get_install_abis`;
	echo $#
}
pkg_nofetch ()
{
	default
}
pkg_postinst ()
{
	if use persist; then
    	ewarn "The persist/timestamp feature is disabled by default upstream.";
    	ewarn "It may not be as secure as on OpenBSD where proper kernel support exists.";
	fi;
	if [[ -z "${REPLACING_VERSIONS}" ]]; then
    	elog "By default, doas will deny all actions.";
    	elog "You need to create your own custom configuration at ${EROOT}/etc/doas.conf.";
    	elog "See https://wiki.gentoo.org/wiki/Doas for guidance.";
	fi
}
src_compile ()
{
	default
}
src_configure ()
{
	tc-export CC AR;
	./configure --prefix="${EPREFIX}"/usr --sysconfdir="${EPREFIX}"/etc $(use_with pam) $(use_with persist timestamp) || die "Configure failed"
}
src_install ()
{
	default
}
src_prepare ()
{
	default
}
src_test ()
{
	default
}
src_unpack ()
{
	default
}
tc-arch ()
{
	tc-ninja_magic_to_arch portage "$@"
}
tc-arch-kernel ()
{
	tc-ninja_magic_to_arch kern "$@"
}
tc-check-openmp ()
{
	if ! _tc-has-openmp; then
    	eerror "Your current compiler does not support OpenMP!";
    	if tc-is-gcc; then
        	eerror "Enable OpenMP support by building sys-devel/gcc with USE=\"openmp\".";
    	else
        	if tc-is-clang; then
            	eerror "OpenMP support in sys-devel/clang is provided by sys-libs/libomp.";
        	fi;
    	fi;
    	die "Active compiler does not have required support for OpenMP";
	fi
}
tc-cpp-is-true ()
{
	local CONDITION=${1};
	shift;
	$(tc-getTARGET_CPP) "${@}" -P - <<-EOF > /dev/null 2>&1
#if ${CONDITION}
true
#else
#error false
#endif
EOF

}
tc-detect-is-softfloat ()
{
	[[ $(tc-getTARGET_CPP) == "gcc -E" ]] && return 1;
	case ${CTARGET:-${CHOST}} in
    	*-newlib | *-elf | *-eabi | arm64-apple-darwin*)
        	return 1
    	;;
    	arm*)
        	if tc-cpp-is-true "defined(__ARM_PCS_VFP)"; then
            	echo "no";
        	else
            	if tc-cpp-is-true "defined(__SOFTFP__)"; then
                	echo "yes";
            	else
                	echo "softfp";
            	fi;
        	fi;
        	return 0
    	;;
    	*)
        	return 1
    	;;
	esac
}
tc-enables-cxx-assertions ()
{
	tc-cpp-is-true "defined(_GLIBCXX_ASSERTIONS) || defined(_LIBCPP_ENABLE_ASSERTIONS) || defined(_LIBCPP_ENABLE_HARDENED_MODE)" ${CPPFLAGS} ${CXXFLAGS}
}
tc-enables-fortify-source ()
{
	tc-cpp-is-true "defined(_FORTIFY_SOURCE)" ${CPPFLAGS} ${CFLAGS} ${CXXFLAGS}
}
tc-enables-pie ()
{
	tc-cpp-is-true "defined(__PIE__)" ${CPPFLAGS} ${CFLAGS} ${CXXFLAGS}
}
tc-enables-ssp ()
{
	tc-cpp-is-true "defined(__SSP__) || defined(__SSP_STRONG__) || defined(__SSP_ALL__)" ${CPPFLAGS} ${CFLAGS} ${CXXFLAGS}
}
tc-enables-ssp-all ()
{
	tc-cpp-is-true "defined(__SSP_ALL__)" ${CPPFLAGS} ${CFLAGS} ${CXXFLAGS}
}
tc-enables-ssp-strong ()
{
	tc-cpp-is-true "defined(__SSP_STRONG__) || defined(__SSP_ALL__)" ${CPPFLAGS} ${CFLAGS} ${CXXFLAGS}
}
tc-endian ()
{
	local host=$1;
	[[ -z ${host} ]] && host=${CTARGET:-${CHOST}};
	host=${host%%-*};
	case ${host} in
    	aarch64*be)
        	echo big
    	;;
    	aarch64)
        	echo little
    	;;
    	alpha*)
        	echo little
    	;;
    	arc*b*)
        	echo big
    	;;
    	arc*)
        	echo little
    	;;
    	arm*b*)
        	echo big
    	;;
    	arm*)
        	echo little
    	;;
    	cris*)
        	echo little
    	;;
    	hppa*)
        	echo big
    	;;
    	i?86*)
        	echo little
    	;;
    	ia64*)
        	echo little
    	;;
    	loongarch*)
        	echo little
    	;;
    	m68*)
        	echo big
    	;;
    	mips*l*)
        	echo little
    	;;
    	mips*)
        	echo big
    	;;
    	powerpc*le)
        	echo little
    	;;
    	powerpc*)
        	echo big
    	;;
    	riscv*)
        	echo little
    	;;
    	s390*)
        	echo big
    	;;
    	sh*b*)
        	echo big
    	;;
    	sh*)
        	echo little
    	;;
    	sparc*)
        	echo big
    	;;
    	x86_64*)
        	echo little
    	;;
    	*)
        	echo wtf
    	;;
	esac
}
tc-env_build ()
{
	tc-export_build_env;
	CFLAGS=${BUILD_CFLAGS} CXXFLAGS=${BUILD_CXXFLAGS} CPPFLAGS=${BUILD_CPPFLAGS} LDFLAGS=${BUILD_LDFLAGS} AR=$(tc-getBUILD_AR) AS=$(tc-getBUILD_AS) CC=$(tc-getBUILD_CC) CPP=$(tc-getBUILD_CPP) CXX=$(tc-getBUILD_CXX) LD=$(tc-getBUILD_LD) NM=$(tc-getBUILD_NM) PKG_CONFIG=$(tc-getBUILD_PKG_CONFIG) RANLIB=$(tc-getBUILD_RANLIB) READELF=$(tc-getBUILD_READELF) "$@"
}
tc-export ()
{
	local var;
	for var in "$@";
	do
    	[[ $(type -t "tc-get${var}") != "function" ]] && die "tc-export: invalid export variable '${var}'";
    	"tc-get${var}" > /dev/null;
	done
}
tc-export_build_env ()
{
	tc-export "$@";
	if tc-is-cross-compiler; then
    	: "${BUILD_CFLAGS:=-O1 -pipe}";
    	: "${BUILD_CXXFLAGS:=-O1 -pipe}";
    	: "${BUILD_CPPFLAGS:= }";
    	: "${BUILD_LDFLAGS:= }";
	else
    	: "${BUILD_CFLAGS:=${CFLAGS}}";
    	: "${BUILD_CXXFLAGS:=${CXXFLAGS}}";
    	: "${BUILD_CPPFLAGS:=${CPPFLAGS}}";
    	: "${BUILD_LDFLAGS:=${LDFLAGS}}";
	fi;
	export BUILD_{C,CXX,CPP,LD}FLAGS;
	local v;
	for v in BUILD_{C,CXX,CPP,LD}FLAGS;
	do
    	export ${v#BUILD_}_FOR_BUILD="${!v}";
	done
}
tc-get-build-ptr-size ()
{
	$(tc-getBUILD_CPP) -P - <<< __SIZEOF_POINTER__ || die "Could not determine CBUILD pointer size"
}
tc-get-c-rtlib ()
{
	local res=$($(tc-getCC) ${CPPFLAGS} ${CFLAGS} ${LDFLAGS} -print-libgcc-file-name 2> /dev/null);
	case ${res} in
    	*libclang_rt*)
        	echo compiler-rt
    	;;
    	*libgcc*)
        	echo libgcc
    	;;
    	*)
        	return 1
    	;;
	esac;
	return 0
}
tc-get-compiler-type ()
{
	local code='
#if defined(__PATHSCALE__)
	HAVE_PATHCC
#elif defined(__clang__)
	HAVE_CLANG
#elif defined(__GNUC__)
	HAVE_GCC
#endif
';
	local res=$($(tc-getCPP "$@") -E -P - <<< "${code}");
	case ${res} in
    	*HAVE_PATHCC*)
        	echo pathcc
    	;;
    	*HAVE_CLANG*)
        	echo clang
    	;;
    	*HAVE_GCC*)
        	echo gcc
    	;;
    	*)
        	echo unknown
    	;;
	esac
}
tc-get-cxx-stdlib ()
{
	local code='#include <ciso646>

#if defined(_LIBCPP_VERSION)
	HAVE_LIBCXX
#elif defined(__GLIBCXX__)
	HAVE_LIBSTDCPP
#endif
';
	local res=$($(tc-getCXX) ${CPPFLAGS} ${CXXFLAGS} -x c++ -E -P - <<< "${code}" 2> /dev/null);
	case ${res} in
    	*HAVE_LIBCXX*)
        	echo libc++
    	;;
    	*HAVE_LIBSTDCPP*)
        	echo libstdc++
    	;;
    	*)
        	return 1
    	;;
	esac;
	return 0
}
tc-get-ptr-size ()
{
	$(tc-getCPP) -P - <<< __SIZEOF_POINTER__ || die "Could not determine CHOST pointer size"
}
tc-getAR ()
{
	tc-getPROG AR ar "$@"
}
tc-getAS ()
{
	tc-getPROG AS as "$@"
}
tc-getBUILD_AR ()
{
	tc-getBUILD_PROG AR ar "$@"
}
tc-getBUILD_AS ()
{
	tc-getBUILD_PROG AS as "$@"
}
tc-getBUILD_CC ()
{
	tc-getBUILD_PROG CC gcc "$@"
}
tc-getBUILD_CPP ()
{
	tc-getBUILD_PROG CPP "$(tc-getBUILD_CC) -E" "$@"
}
tc-getBUILD_CXX ()
{
	tc-getBUILD_PROG CXX g++ "$@"
}
tc-getBUILD_LD ()
{
	tc-getBUILD_PROG LD ld "$@"
}
tc-getBUILD_NM ()
{
	tc-getBUILD_PROG NM nm "$@"
}
tc-getBUILD_OBJCOPY ()
{
	tc-getBUILD_PROG OBJCOPY objcopy "$@"
}
tc-getBUILD_PKG_CONFIG ()
{
	tc-getBUILD_PROG PKG_CONFIG pkg-config "$@"
}
tc-getBUILD_PROG ()
{
	local vars="BUILD_$1 $1_FOR_BUILD HOST$1";
	tc-is-cross-compiler || vars+=" $1";
	_tc-getPROG CBUILD "${vars}" "${@:2}"
}
tc-getBUILD_RANLIB ()
{
	tc-getBUILD_PROG RANLIB ranlib "$@"
}
tc-getBUILD_READELF ()
{
	tc-getBUILD_PROG READELF readelf "$@"
}
tc-getBUILD_STRINGS ()
{
	tc-getBUILD_PROG STRINGS strings "$@"
}
tc-getBUILD_STRIP ()
{
	tc-getBUILD_PROG STRIP strip "$@"
}
tc-getCC ()
{
	tc-getPROG CC gcc "$@"
}
tc-getCPP ()
{
	tc-getPROG CPP "${CC:-gcc} -E" "$@"
}
tc-getCXX ()
{
	tc-getPROG CXX g++ "$@"
}
tc-getDLLWRAP ()
{
	tc-getPROG DLLWRAP dllwrap "$@"
}
tc-getF77 ()
{
	tc-getPROG F77 gfortran "$@"
}
tc-getFC ()
{
	tc-getPROG FC gfortran "$@"
}
tc-getGCJ ()
{
	tc-getPROG GCJ gcj "$@"
}
tc-getGO ()
{
	tc-getPROG GO gccgo "$@"
}
tc-getLD ()
{
	tc-getPROG LD ld "$@"
}
tc-getNM ()
{
	tc-getPROG NM nm "$@"
}
tc-getOBJCOPY ()
{
	tc-getPROG OBJCOPY objcopy "$@"
}
tc-getOBJDUMP ()
{
	tc-getPROG OBJDUMP objdump "$@"
}
tc-getPKG_CONFIG ()
{
	tc-getPROG PKG_CONFIG pkg-config "$@"
}
tc-getPROG ()
{
	_tc-getPROG CHOST "$@"
}
tc-getRANLIB ()
{
	tc-getPROG RANLIB ranlib "$@"
}
tc-getRC ()
{
	tc-getPROG RC windres "$@"
}
tc-getREADELF ()
{
	tc-getPROG READELF readelf "$@"
}
tc-getSTRINGS ()
{
	tc-getPROG STRINGS strings "$@"
}
tc-getSTRIP ()
{
	tc-getPROG STRIP strip "$@"
}
tc-getTARGET_CPP ()
{
	if [[ -n ${CTARGET} ]]; then
    	_tc-getPROG CTARGET TARGET_CPP "gcc -E" "$@";
	else
    	tc-getCPP "$@";
	fi
}
tc-has-64bit-time_t ()
{
	$(tc-getCC) ${CFLAGS} ${CPPFLAGS} -c -x c - -o /dev/null <<-EOF &> /dev/null
#include <sys/types.h>
int test[sizeof(time_t) >= 8 ? 1 : -1];
EOF

	return $?
}
tc-has-tls ()
{
	local base="${T}/test-tc-tls";
	cat <<-EOF > "${base}.c"
int foo(int *i) {
static __thread int j = 0;
return *i ? j : *i;
}
EOF

	local flags;
	case $1 in
    	-s)
        	flags="-S"
    	;;
    	-c)
        	flags="-c"
    	;;
    	-l)

    	;;
    	-*)
        	die "Usage: tc-has-tls [-c|-l] [toolchain prefix]"
    	;;
	esac;
	case "${CHOST}" in
    	*-darwin*)
        	: ${flags:=-dynamiclib}
    	;;
    	*)
        	: ${flags:=-fPIC -shared -Wl,-z,defs}
    	;;
	esac;
	[[ $1 == -* ]] && shift;
	$(tc-getCC "$@") ${flags} "${base}.c" -o "${base}" >&/dev/null;
	local ret=$?;
	rm -f "${base}"*;
	return ${ret}
}
tc-is-clang ()
{
	[[ $(tc-get-compiler-type) == clang ]]
}
tc-is-cross-compiler ()
{
	[[ ${CBUILD:-${CHOST}} != ${CHOST} ]]
}
tc-is-gcc ()
{
	[[ $(tc-get-compiler-type) == gcc ]]
}
tc-is-lto ()
{
	local f="${T}/test-lto.o";
	local ret=1;
	case $(tc-get-compiler-type) in
    	clang)
        	$(tc-getCC) ${CFLAGS} -c -o "${f}" -x c - <<< "" || die;
        	llvm-bcanalyzer "${f}" &> /dev/null && ret=0
    	;;
    	gcc)
        	$(tc-getCC) ${CFLAGS} -c -o "${f}" -x c - <<< "" || die;
        	[[ $($(tc-getREADELF) -S "${f}") == *.gnu.lto* ]] && ret=0
    	;;
	esac;
	rm -f "${f}" || die;
	return "${ret}"
}
tc-is-softfloat ()
{
	tc-detect-is-softfloat || tc-tuple-is-softfloat
}
tc-is-static-only ()
{
	local host=${CTARGET:-${CHOST}};
	[[ ${host} == *-mint* ]]
}
tc-ld-disable-gold ()
{
	tc-ld-is-gold "$@" && tc-ld-force-bfd "$@"
}
tc-ld-force-bfd ()
{
	if tc-ld-is-bfd "$@"; then
    	return;
	fi;
	ewarn "Forcing usage of the BFD linker";
	local ld=$(unset LD; tc-getLD "$@");
	local bfd_ld="${ld}.bfd";
	local path_ld=$(type -P "${bfd_ld}" 2> /dev/null);
	[[ -e ${path_ld} ]] && export LD=${bfd_ld};
	if tc-is-gcc || tc-is-clang; then
    	export CFLAGS="${CFLAGS} -fuse-ld=bfd";
    	export CXXFLAGS="${CXXFLAGS} -fuse-ld=bfd";
    	export LDFLAGS="${LDFLAGS} -fuse-ld=bfd";
	fi
}
tc-ld-is-bfd ()
{
	local out;
	local -x LC_ALL=C;
	out=$($(tc-getLD "$@") --version 2>&1);
	if [[ ${out} != "GNU ld"* ]]; then
    	return 1;
	fi;
	local base="${T}/test-tc-linker";
	cat <<-EOF > "${base}.c"
int main(void) { return 0; }
EOF

	out=$($(tc-getCC "$@") ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} -Wl,--version "${base}.c" -o "${base}" 2>&1);
	rm -f "${base}"*;
	if [[ ! ${out} =~ .*^"GNU ld".* ]]; then
    	return 1;
	fi;
	return 0
}
tc-ld-is-gold ()
{
	local out;
	local -x LC_ALL=C;
	out=$($(tc-getLD "$@") --version 2>&1);
	if [[ ${out} == *"GNU gold"* ]]; then
    	return 0;
	fi;
	local base="${T}/test-tc-linker";
	cat <<-EOF > "${base}.c"
int main(void) { return 0; }
EOF

	out=$($(tc-getCC "$@") ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} -Wl,--version "${base}.c" -o "${base}" 2>&1);
	rm -f "${base}"*;
	if [[ ${out} == *"GNU gold"* ]]; then
    	return 0;
	fi;
	return 1
}
tc-ld-is-lld ()
{
	local out;
	local -x LC_ALL=C;
	out=$($(tc-getLD "$@") --version 2>&1);
	if [[ ${out} == *"LLD"* ]]; then
    	return 0;
	fi;
	local base="${T}/test-tc-linker";
	cat <<-EOF > "${base}.c"
int main(void) { return 0; }
EOF

	out=$($(tc-getCC "$@") ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} -Wl,--version "${base}.c" -o "${base}" 2>&1);
	rm -f "${base}"*;
	if [[ ${out} == *"LLD"* ]]; then
    	return 0;
	fi;
	return 1
}
tc-ld-is-mold ()
{
	local out;
	local -x LC_ALL=C;
	out=$($(tc-getLD "$@") --version 2>&1);
	if [[ ${out} == *"mold"* ]]; then
    	return 0;
	fi;
	local base="${T}/test-tc-linker";
	cat <<-EOF > "${base}.c"
int main(void) { return 0; }
EOF

	out=$($(tc-getCC "$@") ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} -Wl,--version "${base}.c" -o "${base}" 2>&1);
	rm -f "${base}"*;
	if [[ ${out} == *"mold"* ]]; then
    	return 0;
	fi;
	return 1
}
tc-ninja_magic_to_arch ()
{
	function _tc_echo_kernel_alias ()
	{
    	[[ ${type} == "kern" ]] && echo $1 || echo $2
	};
	local type=$1;
	local host=$2;
	[[ -z ${host} ]] && host=${CTARGET:-${CHOST}};
	case ${host} in
    	arm64*)
        	echo arm64
    	;;
    	aarch64*)
        	echo arm64
    	;;
    	alpha*)
        	echo alpha
    	;;
    	arc*)
        	echo arc
    	;;
    	arm*)
        	echo arm
    	;;
    	avr*)
        	_tc_echo_kernel_alias avr32 avr
    	;;
    	bfin*)
        	_tc_echo_kernel_alias blackfin bfin
    	;;
    	c6x*)
        	echo c6x
    	;;
    	cris*)
        	echo cris
    	;;
    	frv*)
        	echo frv
    	;;
    	hexagon*)
        	echo hexagon
    	;;
    	hppa*)
        	_tc_echo_kernel_alias parisc hppa
    	;;
    	i?86*)
        	echo x86
    	;;
    	ia64*)
        	echo ia64
    	;;
    	loongarch*)
        	_tc_echo_kernel_alias loongarch loong
    	;;
    	m68*)
        	echo m68k
    	;;
    	metag*)
        	echo metag
    	;;
    	microblaze*)
        	echo microblaze
    	;;
    	mips*)
        	echo mips
    	;;
    	nios2*)
        	echo nios2
    	;;
    	nios*)
        	echo nios
    	;;
    	or1k* | or32*)
        	echo openrisc
    	;;
    	powerpc*)
        	if [[ ${type} == "kern" ]]; then
            	echo powerpc;
        	else
            	if [[ ${host} == powerpc64* ]]; then
                	echo ppc64;
            	else
                	echo ppc;
            	fi;
        	fi
    	;;
    	riscv*)
        	echo riscv
    	;;
    	s390*)
        	echo s390
    	;;
    	score*)
        	echo score
    	;;
    	sh64*)
        	_tc_echo_kernel_alias sh64 sh
    	;;
    	sh*)
        	echo sh
    	;;
    	sparc64*)
        	_tc_echo_kernel_alias sparc64 sparc
    	;;
    	sparc*)
        	[[ ${PROFILE_ARCH} == "sparc64" ]] && _tc_echo_kernel_alias sparc64 sparc || echo sparc
    	;;
    	tile*)
        	echo tile
    	;;
    	vax*)
        	echo vax
    	;;
    	x86_64*)
        	if [[ ${type} == "kern" ]]; then
            	echo x86;
        	else
            	echo amd64;
        	fi
    	;;
    	xtensa*)
        	echo xtensa
    	;;
    	*)
        	echo unknown
    	;;
	esac
}
tc-stack-grows-down ()
{
	case ${ARCH} in
    	hppa | metag)
        	return 1
    	;;
	esac;
	return 0
}
tc-tuple-is-softfloat ()
{
	local CTARGET=${CTARGET:-${CHOST}};
	case ${CTARGET//_/-} in
    	bfin* | h8300*)
        	echo "only"
    	;;
    	*-softfloat-*)
        	echo "yes"
    	;;
    	*-softfp-*)
        	echo "softfp"
    	;;
    	arm*-hardfloat-* | arm*eabihf)
        	echo "no"
    	;;
    	*-newlib | *-elf | *-eabi)
        	echo "no"
    	;;
    	arm64-apple-darwin*)
        	echo "no"
    	;;
    	arm*)
        	echo "yes"
    	;;
    	*)
        	echo "no"
    	;;
	esac
}
ver_cut ()
{
	local range=${1};
	local v=${2:-${PV}};
	local start end;
	local -a comp;
	__eapi7_ver_split "${v}";
	local max=$((${#comp[@]}/2));
	__eapi7_ver_parse_range "${range}" "${max}";
	local IFS=;
	if [[ ${start} -gt 0 ]]; then
    	start=$(( start*2 - 1 ));
	fi;
	echo "${comp[*]:start:end*2-start}"
}
ver_rs ()
{
	local v;
	(( ${#} & 1 )) && v=${@: -1} || v=${PV};
	local start end i;
	local -a comp;
	__eapi7_ver_split "${v}";
	local max=$((${#comp[@]}/2 - 1));
	while [[ ${#} -ge 2 ]]; do
    	__eapi7_ver_parse_range "${1}" "${max}";
    	for ((i = start*2; i <= end*2; i+=2 ))
    	do
        	[[ ${i} -eq 0 && -z ${comp[i]} ]] && continue;
        	comp[i]=${2};
    	done;
    	shift 2;
	done;
	local IFS=;
	echo "${comp[*]}"
}
ver_test ()
{
	local va op vb;
	if [[ $# -eq 3 ]]; then
    	va=${1};
    	shift;
	else
    	va=${PVR};
	fi;
	[[ $# -eq 2 ]] || die "${FUNCNAME}: bad number of arguments";
	op=${1};
	vb=${2};
	case ${op} in
    	-eq | -ne | -lt | -le | -gt | -ge)

    	;;
    	*)
        	die "${FUNCNAME}: invalid operator: ${op}"
    	;;
	esac;
	__eapi7_ver_compare "${va}" "${vb}";
	test $? "${op}" 2
}