rust-common-without-python3native.bbclass: refresh from oe-core

* there were many changes since this was imported, apply following changes:

openembedded-core $ git log --oneline 997d54363a3c..d381122874 -- meta/classes-recipe/rust-common.bbclass meta/classes/rust-common.bbclass
d381122874 rust-common.bbclass: move musl-specific linking fix from rust-source.inc
0c07089bdf rust: Do not use default compiler flags defined in CC crate
3bff689f0c rust: Enable baremetal targets
a918ea5645 rust-common.bbclass: use built-in rust targets for -native builds
f5c1280083 classes: Update classes to match new bitbake class scope functionality
081a391fe0 classes: Add SPDX license identifiers
880c1ea3ed classes: Add copyright statements to files without one
ef347bd395 rust-common: Remove conflict with utils create_wrapper
06af65757b rust-common: Set rustlibdir to match target expectation
f35d5af06d rust-common: Simplify libc handling
dc134c0311 rust-common: Update to match cross targets
d02c28b221 rust-common/rust: Improve bootstrap BUILD_SYS handling
9160e4a375 rust: Generate per recipe target configuration files
dfff5a1767 rust-common: Rework wrappers to handle musl
1a992268e5 rust-common: Drop export directive from wrappers
e2fc083529 rust-common: Add CXXFLAGS
38b61aeaf8 rust-common: Fix sstate signatures between arm hf and non-hf
67b4e0fdb1 rust-common: override RUST_LIBC for crosssdk
c13afbade8 rust: Introduce RUST_BUILD_ARCH
9ab61e3cfe rust: Introduce arch_to_rust_arch()

  to fix firefox.do_configure failure:

|  0:04.86 checking MOZ_PULSEAUDIO_LIBS... -lpulse -pthread
|  0:04.86 checking for rustc... /OE/build/test-oe-build-time/poky/build/tmp/work/core2-64-poky-linux/firefox/68.9.0esr/recipe-sysroot-native/usr/bin/rustc
|  0:04.86 checking for cargo... /OE/build/test-oe-build-time/poky/build/tmp/work/core2-64-poky-linux/firefox/68.9.0esr/recipe-sysroot-native/usr/bin/cargo
|  0:04.92 checking rustc version... 1.70.0
|  0:04.93 checking cargo version... 1.70.0
|  0:04.95 checking rust host... x86_64-linux
|  0:04.95 checking rust target... x86_64-poky-linux
|  0:04.95 checking for rust target triplet... x86_64-poky-linux
|  0:04.95 checking for rust host triplet... x86_64-linux
|  0:04.95 ERROR: The rust compiler host (x86_64-unknown-linux-gnu) is not suitable for the configure host (x86_64-pc-linux-gnu/x86_64-linux).
|  0:04.98 *** Fix above errors and then restart with\
|  0:04.98                "./mach build"
|  0:04.98 make: *** [client.mk:115: configure] Error 1

* keep in mind that I'm still not interested in maintaining firefox
  recipe, I need it just to measure build time, nobody should use
  this unmaintained version for anything serious

Signed-off-by: Martin Jansa <Martin.Jansa@gmail.com>

Author: shr-project

meta-firefox/classes/mozilla.bbclass

@@ -29,9 +29,11 @@ export HOST_AR = "${BUILD_AR}"
 mozilla_run_mach() {
 	export SHELL="/bin/sh"
 	export RUSTFLAGS="${RUSTFLAGS} -Cpanic=unwind"
-	export RUST_HOST="${BUILD_SYS}"
-	export RUST_TARGET="${TARGET_SYS}"
-	export RUST_TARGET_PATH="${STAGING_LIBDIR_NATIVE}/rustlib"
+	# this needs to match with:
+	# firefox/68.9.0esr $ recipe-sysroot-native/usr/bin/rustc --version --verbose | grep ^host
+	# host: x86_64-unknown-linux-gnu
+	export RUST_HOST="${RUST_BUILD_SYS}"
+	export RUST_TARGET="${RUST_HOST_SYS}"
 	export BINDGEN_MFLOAT="${@bb.utils.contains('TUNE_CCARGS_MFLOAT', 'hard', '-mfloat-abi=hard', '', d)}"
 	export BINDGEN_CFLAGS="--target=${TARGET_SYS} --sysroot=${RECIPE_SYSROOT} ${BINDGEN_MFLOAT}"
 

meta-firefox/classes/rust-common-without-python3native.bbclass

@@ -1,39 +1,25 @@
+#
+# Copyright OpenEmbedded Contributors
+#
+# SPDX-License-Identifier: MIT
+#
+
 # removed, because firefox fails to configure when it finds native python3 instead of python2.7 from HOSTTOOLS
 # inherit python3native
+inherit rust-target-config
 
 # Common variables used by all Rust builds
-export rustlibdir = "${libdir}/rust"
+export rustlibdir = "${libdir}/rustlib/${RUST_HOST_SYS}/lib"
 FILES:${PN} += "${rustlibdir}/*.so"
 FILES:${PN}-dev += "${rustlibdir}/*.rlib ${rustlibdir}/*.rmeta"
 FILES:${PN}-dbg += "${rustlibdir}/.debug"
 
-RUSTLIB = "-L ${STAGING_LIBDIR}/rust"
+RUSTLIB = "-L ${STAGING_DIR_HOST}${rustlibdir}"
 RUST_DEBUG_REMAP = "--remap-path-prefix=${WORKDIR}=/usr/src/debug/${PN}/${EXTENDPE}${PV}-${PR}"
 RUSTFLAGS += "${RUSTLIB} ${RUST_DEBUG_REMAP}"
 RUSTLIB_DEP ?= "libstd-rs"
-export RUST_TARGET_PATH = "${STAGING_LIBDIR_NATIVE}/rustlib"
 RUST_PANIC_STRATEGY ?= "unwind"
 
-# Native builds are not effected by TCLIBC. Without this, rust-native
-# thinks it's "target" (i.e. x86_64-linux) is a musl target.
-RUST_LIBC = "${TCLIBC}"
-RUST_LIBC:class-native = "glibc"
-
-def determine_libc(d, thing):
-    '''Determine which libc something should target'''
-
-    # BUILD is never musl, TARGET may be musl or glibc,
-    # HOST could be musl, but only if a compiler is built to be run on
-    # target in which case HOST_SYS != BUILD_SYS.
-    if thing == 'TARGET':
-        libc = d.getVar('RUST_LIBC')
-    elif thing == 'BUILD' and (d.getVar('HOST_SYS') != d.getVar('BUILD_SYS')):
-        libc = d.getVar('RUST_LIBC')
-    else:
-        libc = d.getVar('RUST_LIBC:class-native')
-
-    return libc
-
 def target_is_armv7(d):
     '''Determine if target is armv7'''
     # TUNE_FEATURES may include arm* even if the target is not arm
@@ -63,31 +49,31 @@ def rust_base_triple(d, thing):
     '''
 
     # The llvm-target for armv7 is armv7-unknown-linux-gnueabihf
-    if thing == "TARGET" and target_is_armv7(d):
+    if d.getVar('{}_ARCH'.format(thing)) == d.getVar('TARGET_ARCH') and target_is_armv7(d):
         arch = "armv7"
     else:
         arch = oe.rust.arch_to_rust_arch(d.getVar('{}_ARCH'.format(thing)))
 
-    # All the Yocto targets are Linux and are 'unknown'
-    vendor = "-unknown"
-    os = d.getVar('{}_OS'.format(thing))
-    libc = determine_libc(d, thing)
-
-    # Prefix with a dash and convert glibc -> gnu
-    if libc == "glibc":
-        libc = "-gnu"
-    elif libc == "musl":
-        libc = "-musl"
-
-    # Don't double up musl (only appears to be the case on aarch64)
-    if os == "linux-musl":
-        if libc != "-musl":
-            bb.fatal("{}_OS was '{}' but TCLIBC was not 'musl'".format(thing, os))
-        os = "linux"
+    # Substituting "unknown" when vendor is empty will match rust's standard
+    # targets when building native recipes (including rust-native itself)
+    vendor = d.getVar('{}_VENDOR'.format(thing)) or "-unknown"
 
+    # Default to glibc
+    libc = "-gnu"
+    os = d.getVar('{}_OS'.format(thing))
     # This catches ARM targets and appends the necessary hard float bits
     if os == "linux-gnueabi" or os == "linux-musleabi":
         libc = bb.utils.contains('TUNE_FEATURES', 'callconvention-hard', 'hf', '', d)
+    elif "musl" in os:
+        libc = "-musl"
+        os = "linux"
+    elif "elf" in os:
+        libc = "-elf"
+        os = "none"
+    elif "eabi" in os:
+        libc = "-eabi"
+        os = "none"
+
     return arch + vendor + '-' + os + libc
 
 
@@ -112,13 +98,16 @@ RUST_BUILD_ARCH = "${@oe.rust.arch_to_rust_arch(d.getVar('BUILD_ARCH'))}"
 # Rust additionally will use two additional cases:
 # - undecorated (e.g. CC) - equivalent to TARGET
 # - triple suffix (e.g. CC:x86_64_unknown_linux_gnu) - both
-#   see: https://github.com/alexcrichton/gcc-rs
+#   see: https://github.com/rust-lang/cc-rs
 # The way that Rust's internal triples and Yocto triples are mapped together
 # its likely best to not use the triple suffix due to potential confusion.
 
 RUST_BUILD_SYS = "${@rust_base_triple(d, 'BUILD')}"
+RUST_BUILD_SYS[vardepvalue] = "${RUST_BUILD_SYS}"
 RUST_HOST_SYS = "${@rust_base_triple(d, 'HOST')}"
+RUST_HOST_SYS[vardepvalue] = "${RUST_HOST_SYS}"
 RUST_TARGET_SYS = "${@rust_base_triple(d, 'TARGET')}"
+RUST_TARGET_SYS[vardepvalue] = "${RUST_TARGET_SYS}"
 
 # wrappers to get around the fact that Rust needs a single
 # binary but Yocto's compiler and linker commands have
@@ -135,26 +124,46 @@ RUST_TARGET_CXX = "${WRAPPER_DIR}/target-rust-cxx"
 RUST_TARGET_CCLD = "${WRAPPER_DIR}/target-rust-ccld"
 RUST_TARGET_AR = "${WRAPPER_DIR}/target-rust-ar"
 
-create_wrapper () {
+create_wrapper_rust () {
 	file="$1"
 	shift
+	extras="$1"
+	shift
+	crate_cc_extras="$1"
+	shift
 
 	cat <<- EOF > "${file}"
 	#!/usr/bin/env python3
 	import os, sys
 	orig_binary = "$@"
+	extras = "${extras}"
+
+	# Apply a required subset of CC crate compiler flags
+	# when we build a target recipe for a non-bare-metal target.
+	# https://github.com/rust-lang/cc-rs/blob/main/src/lib.rs#L1614
+	if "CRATE_CC_NO_DEFAULTS" in os.environ.keys() and \
+	   "TARGET" in os.environ.keys() and not "-none-" in os.environ["TARGET"]:
+	    orig_binary += "${crate_cc_extras}"
+
 	binary = orig_binary.split()[0]
 	args = orig_binary.split() + sys.argv[1:]
+	if extras:
+	    args.append(extras)
 	os.execvp(binary, args)
 	EOF
 	chmod +x "${file}"
 }
 
-export WRAPPER_TARGET_CC = "${CC}"
-export WRAPPER_TARGET_CXX = "${CXX}"
-export WRAPPER_TARGET_CCLD = "${CCLD}"
-export WRAPPER_TARGET_LDFLAGS = "${LDFLAGS}"
-export WRAPPER_TARGET_AR = "${AR}"
+WRAPPER_TARGET_CC = "${CC}"
+WRAPPER_TARGET_CXX = "${CXX}"
+WRAPPER_TARGET_CCLD = "${CCLD}"
+WRAPPER_TARGET_LDFLAGS = "${LDFLAGS}"
+WRAPPER_TARGET_EXTRALD = ""
+# see recipes-devtools/gcc/gcc/0018-Add-ssp_nonshared-to-link-commandline-for-musl-targe.patch
+# we need to link with ssp_nonshared on musl to avoid "undefined reference to `__stack_chk_fail_local'"
+# when building MACHINE=qemux86 for musl
+WRAPPER_TARGET_EXTRALD:libc-musl = "-lssp_nonshared"
+WRAPPER_TARGET_AR = "${AR}"
 
 # compiler is used by gcc-rs
 # linker is used by rustc/cargo
@@ -163,22 +172,22 @@ do_rust_create_wrappers () {
 	mkdir -p "${WRAPPER_DIR}"
 
 	# Yocto Build / Rust Host C compiler
-	create_wrapper "${RUST_BUILD_CC}" "${BUILD_CC}"
+	create_wrapper_rust "${RUST_BUILD_CC}" "" "${CRATE_CC_FLAGS}" "${BUILD_CC}"
 	# Yocto Build / Rust Host C++ compiler
-	create_wrapper "${RUST_BUILD_CXX}" "${BUILD_CXX}"
+	create_wrapper_rust "${RUST_BUILD_CXX}" "" "${CRATE_CC_FLAGS}" "${BUILD_CXX}"
 	# Yocto Build / Rust Host linker
-	create_wrapper "${RUST_BUILD_CCLD}" "${BUILD_CCLD}" "${BUILD_LDFLAGS}"
+	create_wrapper_rust "${RUST_BUILD_CCLD}" "" "" "${BUILD_CCLD}" "${BUILD_LDFLAGS}"
 	# Yocto Build / Rust Host archiver
-	create_wrapper "${RUST_BUILD_AR}" "${BUILD_AR}"
+	create_wrapper_rust "${RUST_BUILD_AR}" "" "" "${BUILD_AR}"
 
 	# Yocto Target / Rust Target C compiler
-	create_wrapper "${RUST_TARGET_CC}" "${WRAPPER_TARGET_CC}" "${WRAPPER_TARGET_LDFLAGS}"
+	create_wrapper_rust "${RUST_TARGET_CC}" "${WRAPPER_TARGET_EXTRALD}" "${CRATE_CC_FLAGS}" "${WRAPPER_TARGET_CC}" "${WRAPPER_TARGET_LDFLAGS}"
 	# Yocto Target / Rust Target C++ compiler
-	create_wrapper "${RUST_TARGET_CXX}" "${WRAPPER_TARGET_CXX}"
+	create_wrapper_rust "${RUST_TARGET_CXX}" "${WRAPPER_TARGET_EXTRALD}" "${CRATE_CC_FLAGS}" "${WRAPPER_TARGET_CXX}" "${CXXFLAGS}"
 	# Yocto Target / Rust Target linker
-	create_wrapper "${RUST_TARGET_CCLD}" "${WRAPPER_TARGET_CCLD}" "${WRAPPER_TARGET_LDFLAGS}"
+	create_wrapper_rust "${RUST_TARGET_CCLD}" "${WRAPPER_TARGET_EXTRALD}" "" "${WRAPPER_TARGET_CCLD}" "${WRAPPER_TARGET_LDFLAGS}"
 	# Yocto Target / Rust Target archiver
-	create_wrapper "${RUST_TARGET_AR}" "${WRAPPER_TARGET_AR}"
+	create_wrapper_rust "${RUST_TARGET_AR}" "" "" "${WRAPPER_TARGET_AR}"
 
 }