From 8f4b2226aa9a4c63ab9f3a050e0b79615544886e Mon Sep 17 00:00:00 2001 From: Nathan Chancellor Date: Mon, 18 Nov 2024 15:12:12 -0700 Subject: [PATCH 1/4] buildroot/rebuild.py: Add '--savedefconfig' It is helpful to run savedefconfig when upgrading Buildroot to make sure that options do not get silently disabled or changed but up until this point, savedefconfig has only been run when editing a configuration file, which is annoying when building all images. Add a flag to allow running savedefconfig without editing so that it can be done non-interactively. Signed-off-by: Nathan Chancellor --- buildroot/rebuild.py | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/buildroot/rebuild.py b/buildroot/rebuild.py index 7e33cc7..f6229bb 100755 --- a/buildroot/rebuild.py +++ b/buildroot/rebuild.py @@ -38,7 +38,7 @@ def buildroot_make(make_arg=None, **kwargs): subprocess.run(make_cmd, **kwargs, check=True, cwd=SRC_FOLDER) -def build_image(architecture, edit_config): +def build_image(architecture, edit_config, savedefconfig): buildroot_make('clean') config = Path(ROOT_FOLDER, f"{architecture}.config") @@ -50,6 +50,7 @@ def build_image(architecture, edit_config): buildroot_make('defconfig', env={**os.environ, 'BR2_DEFCONFIG': config}) if edit_config: buildroot_make('menuconfig') + if edit_config or savedefconfig: buildroot_make('savedefconfig') buildroot_make() @@ -141,6 +142,10 @@ def parse_arguments(): '--release', action='store_true', help=f"Create a release on GitHub (tag: {RELEASE_TAG})") + parser.add_argument('-s', + '--savedefconfig', + action='store_true', + help='Run savedefconfig after configuration stage') return parser.parse_args() @@ -156,7 +161,7 @@ def parse_arguments(): download_and_extract_buildroot() for arch in architectures: - build_image(arch, args.edit_config) + build_image(arch, args.edit_config, args.savedefconfig) if args.release: release_images() From 842a2eb9675fff17b4897bffe39074d633981102 Mon Sep 17 00:00:00 2001 From: Nathan Chancellor Date: Mon, 18 Nov 2024 14:36:09 -0700 Subject: [PATCH 2/4] buildroot: Upgrade to 2024.02.8 This is the latest LTS release. Update the LoongArch patch with the latest version available on the Buildroot mailing list. Signed-off-by: Nathan Chancellor --- ...xun_yang_loongarch64_initial_support.patch | 3279 +++++++++++++++++ buildroot/arm.config | 1 - buildroot/buildroot-2023.02.2.tar.gz.sha256 | 1 - buildroot/buildroot-2024.02.8.tar.gz.sha256 | 1 + buildroot/loongarch.config | 2 - buildroot/rebuild.py | 2 +- ...oongarch_architecture_toolchain_only.patch | 193 - 7 files changed, 3281 insertions(+), 198 deletions(-) create mode 100644 buildroot/20240524_jiaxun_yang_loongarch64_initial_support.patch delete mode 100644 buildroot/buildroot-2023.02.2.tar.gz.sha256 create mode 100644 buildroot/buildroot-2024.02.8.tar.gz.sha256 delete mode 100644 buildroot/v3_20221212_duanzhiwei_buildroot_add_basic_support_for_loongarch_architecture_toolchain_only.patch diff --git a/buildroot/20240524_jiaxun_yang_loongarch64_initial_support.patch b/buildroot/20240524_jiaxun_yang_loongarch64_initial_support.patch new file mode 100644 index 0000000..026ac36 --- /dev/null +++ b/buildroot/20240524_jiaxun_yang_loongarch64_initial_support.patch @@ -0,0 +1,3279 @@ +From git@z Thu Jan 1 00:00:00 1970 +Subject: [PATCH 1/7] support/gnuconfig: Bump version to 2024-01-01 +From: Jiaxun Yang +Date: Fri, 24 May 2024 20:36:35 +0100 +Message-Id: <20240524-loongarch64-v1-1-d24078d79cd5@flygoat.com> +MIME-Version: 1.0 +Content-Type: text/plain; charset="utf-8" +Content-Transfer-Encoding: 7bit + +Bump version to 2024-01-01 with update script to include +loongarch configurations. + +Signed-off-by: Jiaxun Yang +Link: https://lore.kernel.org/r/20240524-loongarch64-v1-1-d24078d79cd5@flygoat.com +--- + support/gnuconfig/README.buildroot | 2 +- + support/gnuconfig/config.guess | 1233 ++++++++++++++++++++---------------- + support/gnuconfig/config.sub | 302 ++++++--- + 3 files changed, 894 insertions(+), 643 deletions(-) + +diff --git a/support/gnuconfig/README.buildroot b/support/gnuconfig/README.buildroot +index 952eea8b1073..f34a6566bdea 100644 +--- a/support/gnuconfig/README.buildroot ++++ b/support/gnuconfig/README.buildroot +@@ -18,4 +18,4 @@ Run the script 'update' in this directory, and commit the result. + The current Buildroot version is based on this commit of the config.git + repository (leave alone on its own line, the script updates it): + +-d7a4dee7cc25e332b990d0a6d9f0ddd42cb33cf5 ++948ae97ca5703224bd3eada06b7a69f40dd15a02 +diff --git a/support/gnuconfig/config.guess b/support/gnuconfig/config.guess +index 8d70ec2b2633..f6d217a49f8f 100755 +--- a/support/gnuconfig/config.guess ++++ b/support/gnuconfig/config.guess +@@ -1,12 +1,14 @@ + #! /bin/sh + # Attempt to guess a canonical system name. +-# Copyright 1992-2020 Free Software Foundation, Inc. ++# Copyright 1992-2024 Free Software Foundation, Inc. + +-timestamp='2020-09-19' ++# shellcheck disable=SC2006,SC2268 # see below for rationale ++ ++timestamp='2024-01-01' + + # This file is free software; you can redistribute it and/or modify it + # under the terms of the GNU General Public License as published by +-# the Free Software Foundation; either version 3 of the License, or ++# the Free Software Foundation, either version 3 of the License, or + # (at your option) any later version. + # + # This program is distributed in the hope that it will be useful, but +@@ -27,17 +29,25 @@ timestamp='2020-09-19' + # Originally written by Per Bothner; maintained since 2000 by Ben Elliston. + # + # You can get the latest version of this script from: +-# https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess ++# https://git.savannah.gnu.org/cgit/config.git/plain/config.guess + # + # Please send patches to . + + ++# The "shellcheck disable" line above the timestamp inhibits complaints ++# about features and limitations of the classic Bourne shell that were ++# superseded or lifted in POSIX. However, this script identifies a wide ++# variety of pre-POSIX systems that do not have POSIX shells at all, and ++# even some reasonably current systems (Solaris 10 as case-in-point) still ++# have a pre-POSIX /bin/sh. ++ ++ + me=`echo "$0" | sed -e 's,.*/,,'` + + usage="\ + Usage: $0 [OPTION] + +-Output the configuration name of the system \`$me' is run on. ++Output the configuration name of the system '$me' is run on. + + Options: + -h, --help print this help, then exit +@@ -50,13 +60,13 @@ version="\ + GNU config.guess ($timestamp) + + Originally written by Per Bothner. +-Copyright 1992-2020 Free Software Foundation, Inc. ++Copyright 1992-2024 Free Software Foundation, Inc. + + This is free software; see the source for copying conditions. There is NO + warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." + + help=" +-Try \`$me --help' for more information." ++Try '$me --help' for more information." + + # Parse command line + while test $# -gt 0 ; do +@@ -84,13 +94,16 @@ if test $# != 0; then + exit 1 + fi + ++# Just in case it came from the environment. ++GUESS= ++ + # CC_FOR_BUILD -- compiler used by this script. Note that the use of a + # compiler to aid in system detection is discouraged as it requires + # temporary files to be created and, as you can see below, it is a + # headache to deal with in a portable fashion. + +-# Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still +-# use `HOST_CC' if defined, but it is deprecated. ++# Historically, 'CC_FOR_BUILD' used to be named 'HOST_CC'. We still ++# use 'HOST_CC' if defined, but it is deprecated. + + # Portable tmp directory creation inspired by the Autoconf team. + +@@ -102,7 +115,7 @@ set_cc_for_build() { + # prevent multiple calls if $tmp is already set + test "$tmp" && return 0 + : "${TMPDIR=/tmp}" +- # shellcheck disable=SC2039 ++ # shellcheck disable=SC2039,SC3028 + { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } || + { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir "$tmp" 2>/dev/null) ; } || + { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir "$tmp" 2>/dev/null) && echo "Warning: creating insecure temp directory" >&2 ; } || +@@ -112,7 +125,7 @@ set_cc_for_build() { + ,,) echo "int x;" > "$dummy.c" + for driver in cc gcc c89 c99 ; do + if ($driver -c -o "$dummy.o" "$dummy.c") >/dev/null 2>&1 ; then +- CC_FOR_BUILD="$driver" ++ CC_FOR_BUILD=$driver + break + fi + done +@@ -133,38 +146,57 @@ fi + + UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown + UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown +-UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown ++UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown + UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown + +-case "$UNAME_SYSTEM" in ++case $UNAME_SYSTEM in + Linux|GNU|GNU/*) +- # If the system lacks a compiler, then just pick glibc. +- # We could probably try harder. +- LIBC=gnu ++ LIBC=unknown + + set_cc_for_build + cat <<-EOF > "$dummy.c" ++ #if defined(__ANDROID__) ++ LIBC=android ++ #else + #include + #if defined(__UCLIBC__) + LIBC=uclibc + #elif defined(__dietlibc__) + LIBC=dietlibc ++ #elif defined(__GLIBC__) ++ LIBC=gnu ++ #elif defined(__LLVM_LIBC__) ++ LIBC=llvm + #else + #include ++ /* First heuristic to detect musl libc. */ + #ifdef __DEFINED_va_list + LIBC=musl +- #else +- LIBC=gnu ++ #endif + #endif + #endif + EOF +- eval "`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^LIBC' | sed 's, ,,g'`" ++ cc_set_libc=`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^LIBC' | sed 's, ,,g'` ++ eval "$cc_set_libc" ++ ++ # Second heuristic to detect musl libc. ++ if [ "$LIBC" = unknown ] && ++ command -v ldd >/dev/null && ++ ldd --version 2>&1 | grep -q ^musl; then ++ LIBC=musl ++ fi ++ ++ # If the system lacks a compiler, then just pick glibc. ++ # We could probably try harder. ++ if [ "$LIBC" = unknown ]; then ++ LIBC=gnu ++ fi + ;; + esac + + # Note: order is significant - the case branches are not exclusive. + +-case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in ++case $UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION in + *:NetBSD:*:*) + # NetBSD (nbsd) targets should (where applicable) match one or + # more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*, +@@ -176,12 +208,12 @@ case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in + # + # Note: NetBSD doesn't particularly care about the vendor + # portion of the name. We always set it to "unknown". +- sysctl="sysctl -n hw.machine_arch" + UNAME_MACHINE_ARCH=`(uname -p 2>/dev/null || \ +- "/sbin/$sysctl" 2>/dev/null || \ +- "/usr/sbin/$sysctl" 2>/dev/null || \ ++ /sbin/sysctl -n hw.machine_arch 2>/dev/null || \ ++ /usr/sbin/sysctl -n hw.machine_arch 2>/dev/null || \ + echo unknown)` +- case "$UNAME_MACHINE_ARCH" in ++ case $UNAME_MACHINE_ARCH in ++ aarch64eb) machine=aarch64_be-unknown ;; + armeb) machine=armeb-unknown ;; + arm*) machine=arm-unknown ;; + sh3el) machine=shl-unknown ;; +@@ -190,13 +222,13 @@ case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in + earmv*) + arch=`echo "$UNAME_MACHINE_ARCH" | sed -e 's,^e\(armv[0-9]\).*$,\1,'` + endian=`echo "$UNAME_MACHINE_ARCH" | sed -ne 's,^.*\(eb\)$,\1,p'` +- machine="${arch}${endian}"-unknown ++ machine=${arch}${endian}-unknown + ;; +- *) machine="$UNAME_MACHINE_ARCH"-unknown ;; ++ *) machine=$UNAME_MACHINE_ARCH-unknown ;; + esac + # The Operating System including object format, if it has switched + # to ELF recently (or will in the future) and ABI. +- case "$UNAME_MACHINE_ARCH" in ++ case $UNAME_MACHINE_ARCH in + earm*) + os=netbsdelf + ;; +@@ -217,7 +249,7 @@ case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in + ;; + esac + # Determine ABI tags. +- case "$UNAME_MACHINE_ARCH" in ++ case $UNAME_MACHINE_ARCH in + earm*) + expr='s/^earmv[0-9]/-eabi/;s/eb$//' + abi=`echo "$UNAME_MACHINE_ARCH" | sed -e "$expr"` +@@ -228,7 +260,7 @@ case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in + # thus, need a distinct triplet. However, they do not need + # kernel version information, so it can be replaced with a + # suitable tag, in the style of linux-gnu. +- case "$UNAME_VERSION" in ++ case $UNAME_VERSION in + Debian*) + release='-gnu' + ;; +@@ -239,51 +271,57 @@ case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in + # Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM: + # contains redundant information, the shorter form: + # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used. +- echo "$machine-${os}${release}${abi-}" +- exit ;; ++ GUESS=$machine-${os}${release}${abi-} ++ ;; + *:Bitrig:*:*) + UNAME_MACHINE_ARCH=`arch | sed 's/Bitrig.//'` +- echo "$UNAME_MACHINE_ARCH"-unknown-bitrig"$UNAME_RELEASE" +- exit ;; ++ GUESS=$UNAME_MACHINE_ARCH-unknown-bitrig$UNAME_RELEASE ++ ;; + *:OpenBSD:*:*) + UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'` +- echo "$UNAME_MACHINE_ARCH"-unknown-openbsd"$UNAME_RELEASE" +- exit ;; ++ GUESS=$UNAME_MACHINE_ARCH-unknown-openbsd$UNAME_RELEASE ++ ;; ++ *:SecBSD:*:*) ++ UNAME_MACHINE_ARCH=`arch | sed 's/SecBSD.//'` ++ GUESS=$UNAME_MACHINE_ARCH-unknown-secbsd$UNAME_RELEASE ++ ;; + *:LibertyBSD:*:*) + UNAME_MACHINE_ARCH=`arch | sed 's/^.*BSD\.//'` +- echo "$UNAME_MACHINE_ARCH"-unknown-libertybsd"$UNAME_RELEASE" +- exit ;; ++ GUESS=$UNAME_MACHINE_ARCH-unknown-libertybsd$UNAME_RELEASE ++ ;; + *:MidnightBSD:*:*) +- echo "$UNAME_MACHINE"-unknown-midnightbsd"$UNAME_RELEASE" +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-midnightbsd$UNAME_RELEASE ++ ;; + *:ekkoBSD:*:*) +- echo "$UNAME_MACHINE"-unknown-ekkobsd"$UNAME_RELEASE" +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-ekkobsd$UNAME_RELEASE ++ ;; + *:SolidBSD:*:*) +- echo "$UNAME_MACHINE"-unknown-solidbsd"$UNAME_RELEASE" +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-solidbsd$UNAME_RELEASE ++ ;; + *:OS108:*:*) +- echo "$UNAME_MACHINE"-unknown-os108_"$UNAME_RELEASE" +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-os108_$UNAME_RELEASE ++ ;; + macppc:MirBSD:*:*) +- echo powerpc-unknown-mirbsd"$UNAME_RELEASE" +- exit ;; ++ GUESS=powerpc-unknown-mirbsd$UNAME_RELEASE ++ ;; + *:MirBSD:*:*) +- echo "$UNAME_MACHINE"-unknown-mirbsd"$UNAME_RELEASE" +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-mirbsd$UNAME_RELEASE ++ ;; + *:Sortix:*:*) +- echo "$UNAME_MACHINE"-unknown-sortix +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-sortix ++ ;; + *:Twizzler:*:*) +- echo "$UNAME_MACHINE"-unknown-twizzler +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-twizzler ++ ;; + *:Redox:*:*) +- echo "$UNAME_MACHINE"-unknown-redox +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-redox ++ ;; + mips:OSF1:*.*) +- echo mips-dec-osf1 +- exit ;; ++ GUESS=mips-dec-osf1 ++ ;; + alpha:OSF1:*:*) ++ # Reset EXIT trap before exiting to avoid spurious non-zero exit code. ++ trap '' 0 + case $UNAME_RELEASE in + *4.0) + UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'` +@@ -297,7 +335,7 @@ case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in + # covers most systems running today. This code pipes the CPU + # types through head -n 1, so we only detect the type of CPU 0. + ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^ The alpha \(.*\) processor.*$/\1/p' | head -n 1` +- case "$ALPHA_CPU_TYPE" in ++ case $ALPHA_CPU_TYPE in + "EV4 (21064)") + UNAME_MACHINE=alpha ;; + "EV4.5 (21064)") +@@ -334,68 +372,69 @@ case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in + # A Tn.n version is a released field test version. + # A Xn.n version is an unreleased experimental baselevel. + # 1.2 uses "1.2" for uname -r. +- echo "$UNAME_MACHINE"-dec-osf"`echo "$UNAME_RELEASE" | sed -e 's/^[PVTX]//' | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz`" +- # Reset EXIT trap before exiting to avoid spurious non-zero exit code. +- exitcode=$? +- trap '' 0 +- exit $exitcode ;; ++ OSF_REL=`echo "$UNAME_RELEASE" | sed -e 's/^[PVTX]//' | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz` ++ GUESS=$UNAME_MACHINE-dec-osf$OSF_REL ++ ;; + Amiga*:UNIX_System_V:4.0:*) +- echo m68k-unknown-sysv4 +- exit ;; ++ GUESS=m68k-unknown-sysv4 ++ ;; + *:[Aa]miga[Oo][Ss]:*:*) +- echo "$UNAME_MACHINE"-unknown-amigaos +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-amigaos ++ ;; + *:[Mm]orph[Oo][Ss]:*:*) +- echo "$UNAME_MACHINE"-unknown-morphos +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-morphos ++ ;; + *:OS/390:*:*) +- echo i370-ibm-openedition +- exit ;; ++ GUESS=i370-ibm-openedition ++ ;; + *:z/VM:*:*) +- echo s390-ibm-zvmoe +- exit ;; ++ GUESS=s390-ibm-zvmoe ++ ;; + *:OS400:*:*) +- echo powerpc-ibm-os400 +- exit ;; ++ GUESS=powerpc-ibm-os400 ++ ;; + arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*) +- echo arm-acorn-riscix"$UNAME_RELEASE" +- exit ;; ++ GUESS=arm-acorn-riscix$UNAME_RELEASE ++ ;; + arm*:riscos:*:*|arm*:RISCOS:*:*) +- echo arm-unknown-riscos +- exit ;; ++ GUESS=arm-unknown-riscos ++ ;; + SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*) +- echo hppa1.1-hitachi-hiuxmpp +- exit ;; ++ GUESS=hppa1.1-hitachi-hiuxmpp ++ ;; + Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*) + # akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE. +- if test "`(/bin/universe) 2>/dev/null`" = att ; then +- echo pyramid-pyramid-sysv3 +- else +- echo pyramid-pyramid-bsd +- fi +- exit ;; ++ case `(/bin/universe) 2>/dev/null` in ++ att) GUESS=pyramid-pyramid-sysv3 ;; ++ *) GUESS=pyramid-pyramid-bsd ;; ++ esac ++ ;; + NILE*:*:*:dcosx) +- echo pyramid-pyramid-svr4 +- exit ;; ++ GUESS=pyramid-pyramid-svr4 ++ ;; + DRS?6000:unix:4.0:6*) +- echo sparc-icl-nx6 +- exit ;; ++ GUESS=sparc-icl-nx6 ++ ;; + DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*) + case `/usr/bin/uname -p` in +- sparc) echo sparc-icl-nx7; exit ;; +- esac ;; ++ sparc) GUESS=sparc-icl-nx7 ;; ++ esac ++ ;; + s390x:SunOS:*:*) +- echo "$UNAME_MACHINE"-ibm-solaris2"`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`" +- exit ;; ++ SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'` ++ GUESS=$UNAME_MACHINE-ibm-solaris2$SUN_REL ++ ;; + sun4H:SunOS:5.*:*) +- echo sparc-hal-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`" +- exit ;; ++ SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'` ++ GUESS=sparc-hal-solaris2$SUN_REL ++ ;; + sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*) +- echo sparc-sun-solaris2"`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`" +- exit ;; ++ SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'` ++ GUESS=sparc-sun-solaris2$SUN_REL ++ ;; + i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*) +- echo i386-pc-auroraux"$UNAME_RELEASE" +- exit ;; ++ GUESS=i386-pc-auroraux$UNAME_RELEASE ++ ;; + i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*) + set_cc_for_build + SUN_ARCH=i386 +@@ -404,47 +443,50 @@ case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in + # This test works for both compilers. + if test "$CC_FOR_BUILD" != no_compiler_found; then + if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \ +- (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \ ++ (CCOPTS="" $CC_FOR_BUILD -m64 -E - 2>/dev/null) | \ + grep IS_64BIT_ARCH >/dev/null + then + SUN_ARCH=x86_64 + fi + fi +- echo "$SUN_ARCH"-pc-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`" +- exit ;; ++ SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'` ++ GUESS=$SUN_ARCH-pc-solaris2$SUN_REL ++ ;; + sun4*:SunOS:6*:*) + # According to config.sub, this is the proper way to canonicalize + # SunOS6. Hard to guess exactly what SunOS6 will be like, but + # it's likely to be more like Solaris than SunOS4. +- echo sparc-sun-solaris3"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`" +- exit ;; ++ SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'` ++ GUESS=sparc-sun-solaris3$SUN_REL ++ ;; + sun4*:SunOS:*:*) +- case "`/usr/bin/arch -k`" in ++ case `/usr/bin/arch -k` in + Series*|S4*) + UNAME_RELEASE=`uname -v` + ;; + esac +- # Japanese Language versions have a version number like `4.1.3-JL'. +- echo sparc-sun-sunos"`echo "$UNAME_RELEASE"|sed -e 's/-/_/'`" +- exit ;; ++ # Japanese Language versions have a version number like '4.1.3-JL'. ++ SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/-/_/'` ++ GUESS=sparc-sun-sunos$SUN_REL ++ ;; + sun3*:SunOS:*:*) +- echo m68k-sun-sunos"$UNAME_RELEASE" +- exit ;; ++ GUESS=m68k-sun-sunos$UNAME_RELEASE ++ ;; + sun*:*:4.2BSD:*) + UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null` + test "x$UNAME_RELEASE" = x && UNAME_RELEASE=3 +- case "`/bin/arch`" in ++ case `/bin/arch` in + sun3) +- echo m68k-sun-sunos"$UNAME_RELEASE" ++ GUESS=m68k-sun-sunos$UNAME_RELEASE + ;; + sun4) +- echo sparc-sun-sunos"$UNAME_RELEASE" ++ GUESS=sparc-sun-sunos$UNAME_RELEASE + ;; + esac +- exit ;; ++ ;; + aushp:SunOS:*:*) +- echo sparc-auspex-sunos"$UNAME_RELEASE" +- exit ;; ++ GUESS=sparc-auspex-sunos$UNAME_RELEASE ++ ;; + # The situation for MiNT is a little confusing. The machine name + # can be virtually everything (everything which is not + # "atarist" or "atariste" at least should have a processor +@@ -454,41 +496,41 @@ case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in + # MiNT. But MiNT is downward compatible to TOS, so this should + # be no problem. + atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*) +- echo m68k-atari-mint"$UNAME_RELEASE" +- exit ;; ++ GUESS=m68k-atari-mint$UNAME_RELEASE ++ ;; + atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*) +- echo m68k-atari-mint"$UNAME_RELEASE" +- exit ;; ++ GUESS=m68k-atari-mint$UNAME_RELEASE ++ ;; + *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*) +- echo m68k-atari-mint"$UNAME_RELEASE" +- exit ;; ++ GUESS=m68k-atari-mint$UNAME_RELEASE ++ ;; + milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*) +- echo m68k-milan-mint"$UNAME_RELEASE" +- exit ;; ++ GUESS=m68k-milan-mint$UNAME_RELEASE ++ ;; + hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*) +- echo m68k-hades-mint"$UNAME_RELEASE" +- exit ;; ++ GUESS=m68k-hades-mint$UNAME_RELEASE ++ ;; + *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*) +- echo m68k-unknown-mint"$UNAME_RELEASE" +- exit ;; ++ GUESS=m68k-unknown-mint$UNAME_RELEASE ++ ;; + m68k:machten:*:*) +- echo m68k-apple-machten"$UNAME_RELEASE" +- exit ;; ++ GUESS=m68k-apple-machten$UNAME_RELEASE ++ ;; + powerpc:machten:*:*) +- echo powerpc-apple-machten"$UNAME_RELEASE" +- exit ;; ++ GUESS=powerpc-apple-machten$UNAME_RELEASE ++ ;; + RISC*:Mach:*:*) +- echo mips-dec-mach_bsd4.3 +- exit ;; ++ GUESS=mips-dec-mach_bsd4.3 ++ ;; + RISC*:ULTRIX:*:*) +- echo mips-dec-ultrix"$UNAME_RELEASE" +- exit ;; ++ GUESS=mips-dec-ultrix$UNAME_RELEASE ++ ;; + VAX*:ULTRIX*:*:*) +- echo vax-dec-ultrix"$UNAME_RELEASE" +- exit ;; ++ GUESS=vax-dec-ultrix$UNAME_RELEASE ++ ;; + 2020:CLIX:*:* | 2430:CLIX:*:*) +- echo clipper-intergraph-clix"$UNAME_RELEASE" +- exit ;; ++ GUESS=clipper-intergraph-clix$UNAME_RELEASE ++ ;; + mips:*:*:UMIPS | mips:*:*:RISCos) + set_cc_for_build + sed 's/^ //' << EOF > "$dummy.c" +@@ -516,29 +558,29 @@ EOF + dummyarg=`echo "$UNAME_RELEASE" | sed -n 's/\([0-9]*\).*/\1/p'` && + SYSTEM_NAME=`"$dummy" "$dummyarg"` && + { echo "$SYSTEM_NAME"; exit; } +- echo mips-mips-riscos"$UNAME_RELEASE" +- exit ;; ++ GUESS=mips-mips-riscos$UNAME_RELEASE ++ ;; + Motorola:PowerMAX_OS:*:*) +- echo powerpc-motorola-powermax +- exit ;; ++ GUESS=powerpc-motorola-powermax ++ ;; + Motorola:*:4.3:PL8-*) +- echo powerpc-harris-powermax +- exit ;; ++ GUESS=powerpc-harris-powermax ++ ;; + Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*) +- echo powerpc-harris-powermax +- exit ;; ++ GUESS=powerpc-harris-powermax ++ ;; + Night_Hawk:Power_UNIX:*:*) +- echo powerpc-harris-powerunix +- exit ;; ++ GUESS=powerpc-harris-powerunix ++ ;; + m88k:CX/UX:7*:*) +- echo m88k-harris-cxux7 +- exit ;; ++ GUESS=m88k-harris-cxux7 ++ ;; + m88k:*:4*:R4*) +- echo m88k-motorola-sysv4 +- exit ;; ++ GUESS=m88k-motorola-sysv4 ++ ;; + m88k:*:3*:R3*) +- echo m88k-motorola-sysv3 +- exit ;; ++ GUESS=m88k-motorola-sysv3 ++ ;; + AViiON:dgux:*:*) + # DG/UX returns AViiON for all architectures + UNAME_PROCESSOR=`/usr/bin/uname -p` +@@ -547,44 +589,45 @@ EOF + if test "$TARGET_BINARY_INTERFACE"x = m88kdguxelfx || \ + test "$TARGET_BINARY_INTERFACE"x = x + then +- echo m88k-dg-dgux"$UNAME_RELEASE" ++ GUESS=m88k-dg-dgux$UNAME_RELEASE + else +- echo m88k-dg-dguxbcs"$UNAME_RELEASE" ++ GUESS=m88k-dg-dguxbcs$UNAME_RELEASE + fi + else +- echo i586-dg-dgux"$UNAME_RELEASE" ++ GUESS=i586-dg-dgux$UNAME_RELEASE + fi +- exit ;; ++ ;; + M88*:DolphinOS:*:*) # DolphinOS (SVR3) +- echo m88k-dolphin-sysv3 +- exit ;; ++ GUESS=m88k-dolphin-sysv3 ++ ;; + M88*:*:R3*:*) + # Delta 88k system running SVR3 +- echo m88k-motorola-sysv3 +- exit ;; ++ GUESS=m88k-motorola-sysv3 ++ ;; + XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3) +- echo m88k-tektronix-sysv3 +- exit ;; ++ GUESS=m88k-tektronix-sysv3 ++ ;; + Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD) +- echo m68k-tektronix-bsd +- exit ;; ++ GUESS=m68k-tektronix-bsd ++ ;; + *:IRIX*:*:*) +- echo mips-sgi-irix"`echo "$UNAME_RELEASE"|sed -e 's/-/_/g'`" +- exit ;; ++ IRIX_REL=`echo "$UNAME_RELEASE" | sed -e 's/-/_/g'` ++ GUESS=mips-sgi-irix$IRIX_REL ++ ;; + ????????:AIX?:[12].1:2) # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX. +- echo romp-ibm-aix # uname -m gives an 8 hex-code CPU id +- exit ;; # Note that: echo "'`uname -s`'" gives 'AIX ' ++ GUESS=romp-ibm-aix # uname -m gives an 8 hex-code CPU id ++ ;; # Note that: echo "'`uname -s`'" gives 'AIX ' + i*86:AIX:*:*) +- echo i386-ibm-aix +- exit ;; ++ GUESS=i386-ibm-aix ++ ;; + ia64:AIX:*:*) + if test -x /usr/bin/oslevel ; then + IBM_REV=`/usr/bin/oslevel` + else +- IBM_REV="$UNAME_VERSION.$UNAME_RELEASE" ++ IBM_REV=$UNAME_VERSION.$UNAME_RELEASE + fi +- echo "$UNAME_MACHINE"-ibm-aix"$IBM_REV" +- exit ;; ++ GUESS=$UNAME_MACHINE-ibm-aix$IBM_REV ++ ;; + *:AIX:2:3) + if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then + set_cc_for_build +@@ -601,16 +644,16 @@ EOF + EOF + if $CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=`"$dummy"` + then +- echo "$SYSTEM_NAME" ++ GUESS=$SYSTEM_NAME + else +- echo rs6000-ibm-aix3.2.5 ++ GUESS=rs6000-ibm-aix3.2.5 + fi + elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then +- echo rs6000-ibm-aix3.2.4 ++ GUESS=rs6000-ibm-aix3.2.4 + else +- echo rs6000-ibm-aix3.2 ++ GUESS=rs6000-ibm-aix3.2 + fi +- exit ;; ++ ;; + *:AIX:*:[4567]) + IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'` + if /usr/sbin/lsattr -El "$IBM_CPU_ID" | grep ' POWER' >/dev/null 2>&1; then +@@ -619,48 +662,48 @@ EOF + IBM_ARCH=powerpc + fi + if test -x /usr/bin/lslpp ; then +- IBM_REV=`/usr/bin/lslpp -Lqc bos.rte.libc | ++ IBM_REV=`/usr/bin/lslpp -Lqc bos.rte.libc | \ + awk -F: '{ print $3 }' | sed s/[0-9]*$/0/` + else +- IBM_REV="$UNAME_VERSION.$UNAME_RELEASE" ++ IBM_REV=$UNAME_VERSION.$UNAME_RELEASE + fi +- echo "$IBM_ARCH"-ibm-aix"$IBM_REV" +- exit ;; ++ GUESS=$IBM_ARCH-ibm-aix$IBM_REV ++ ;; + *:AIX:*:*) +- echo rs6000-ibm-aix +- exit ;; ++ GUESS=rs6000-ibm-aix ++ ;; + ibmrt:4.4BSD:*|romp-ibm:4.4BSD:*) +- echo romp-ibm-bsd4.4 +- exit ;; ++ GUESS=romp-ibm-bsd4.4 ++ ;; + ibmrt:*BSD:*|romp-ibm:BSD:*) # covers RT/PC BSD and +- echo romp-ibm-bsd"$UNAME_RELEASE" # 4.3 with uname added to +- exit ;; # report: romp-ibm BSD 4.3 ++ GUESS=romp-ibm-bsd$UNAME_RELEASE # 4.3 with uname added to ++ ;; # report: romp-ibm BSD 4.3 + *:BOSX:*:*) +- echo rs6000-bull-bosx +- exit ;; ++ GUESS=rs6000-bull-bosx ++ ;; + DPX/2?00:B.O.S.:*:*) +- echo m68k-bull-sysv3 +- exit ;; ++ GUESS=m68k-bull-sysv3 ++ ;; + 9000/[34]??:4.3bsd:1.*:*) +- echo m68k-hp-bsd +- exit ;; ++ GUESS=m68k-hp-bsd ++ ;; + hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*) +- echo m68k-hp-bsd4.4 +- exit ;; ++ GUESS=m68k-hp-bsd4.4 ++ ;; + 9000/[34678]??:HP-UX:*:*) +- HPUX_REV=`echo "$UNAME_RELEASE"|sed -e 's/[^.]*.[0B]*//'` +- case "$UNAME_MACHINE" in ++ HPUX_REV=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*.[0B]*//'` ++ case $UNAME_MACHINE in + 9000/31?) HP_ARCH=m68000 ;; + 9000/[34]??) HP_ARCH=m68k ;; + 9000/[678][0-9][0-9]) + if test -x /usr/bin/getconf; then + sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null` + sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null` +- case "$sc_cpu_version" in ++ case $sc_cpu_version in + 523) HP_ARCH=hppa1.0 ;; # CPU_PA_RISC1_0 + 528) HP_ARCH=hppa1.1 ;; # CPU_PA_RISC1_1 + 532) # CPU_PA_RISC2_0 +- case "$sc_kernel_bits" in ++ case $sc_kernel_bits in + 32) HP_ARCH=hppa2.0n ;; + 64) HP_ARCH=hppa2.0w ;; + '') HP_ARCH=hppa2.0 ;; # HP-UX 10.20 +@@ -727,12 +770,12 @@ EOF + HP_ARCH=hppa64 + fi + fi +- echo "$HP_ARCH"-hp-hpux"$HPUX_REV" +- exit ;; ++ GUESS=$HP_ARCH-hp-hpux$HPUX_REV ++ ;; + ia64:HP-UX:*:*) +- HPUX_REV=`echo "$UNAME_RELEASE"|sed -e 's/[^.]*.[0B]*//'` +- echo ia64-hp-hpux"$HPUX_REV" +- exit ;; ++ HPUX_REV=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*.[0B]*//'` ++ GUESS=ia64-hp-hpux$HPUX_REV ++ ;; + 3050*:HI-UX:*:*) + set_cc_for_build + sed 's/^ //' << EOF > "$dummy.c" +@@ -762,36 +805,36 @@ EOF + EOF + $CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=`"$dummy"` && + { echo "$SYSTEM_NAME"; exit; } +- echo unknown-hitachi-hiuxwe2 +- exit ;; ++ GUESS=unknown-hitachi-hiuxwe2 ++ ;; + 9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:*) +- echo hppa1.1-hp-bsd +- exit ;; ++ GUESS=hppa1.1-hp-bsd ++ ;; + 9000/8??:4.3bsd:*:*) +- echo hppa1.0-hp-bsd +- exit ;; ++ GUESS=hppa1.0-hp-bsd ++ ;; + *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*) +- echo hppa1.0-hp-mpeix +- exit ;; ++ GUESS=hppa1.0-hp-mpeix ++ ;; + hp7??:OSF1:*:* | hp8?[79]:OSF1:*:*) +- echo hppa1.1-hp-osf +- exit ;; ++ GUESS=hppa1.1-hp-osf ++ ;; + hp8??:OSF1:*:*) +- echo hppa1.0-hp-osf +- exit ;; ++ GUESS=hppa1.0-hp-osf ++ ;; + i*86:OSF1:*:*) + if test -x /usr/sbin/sysversion ; then +- echo "$UNAME_MACHINE"-unknown-osf1mk ++ GUESS=$UNAME_MACHINE-unknown-osf1mk + else +- echo "$UNAME_MACHINE"-unknown-osf1 ++ GUESS=$UNAME_MACHINE-unknown-osf1 + fi +- exit ;; ++ ;; + parisc*:Lites*:*:*) +- echo hppa1.1-hp-lites +- exit ;; ++ GUESS=hppa1.1-hp-lites ++ ;; + C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*) +- echo c1-convex-bsd +- exit ;; ++ GUESS=c1-convex-bsd ++ ;; + C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*) + if getsysinfo -f scalar_acc + then echo c32-convex-bsd +@@ -799,17 +842,18 @@ EOF + fi + exit ;; + C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*) +- echo c34-convex-bsd +- exit ;; ++ GUESS=c34-convex-bsd ++ ;; + C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*) +- echo c38-convex-bsd +- exit ;; ++ GUESS=c38-convex-bsd ++ ;; + C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*) +- echo c4-convex-bsd +- exit ;; ++ GUESS=c4-convex-bsd ++ ;; + CRAY*Y-MP:*:*:*) +- echo ymp-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/' +- exit ;; ++ CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'` ++ GUESS=ymp-cray-unicos$CRAY_REL ++ ;; + CRAY*[A-Z]90:*:*:*) + echo "$UNAME_MACHINE"-cray-unicos"$UNAME_RELEASE" \ + | sed -e 's/CRAY.*\([A-Z]90\)/\1/' \ +@@ -817,112 +861,153 @@ EOF + -e 's/\.[^.]*$/.X/' + exit ;; + CRAY*TS:*:*:*) +- echo t90-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/' +- exit ;; ++ CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'` ++ GUESS=t90-cray-unicos$CRAY_REL ++ ;; + CRAY*T3E:*:*:*) +- echo alphaev5-cray-unicosmk"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/' +- exit ;; ++ CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'` ++ GUESS=alphaev5-cray-unicosmk$CRAY_REL ++ ;; + CRAY*SV1:*:*:*) +- echo sv1-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/' +- exit ;; ++ CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'` ++ GUESS=sv1-cray-unicos$CRAY_REL ++ ;; + *:UNICOS/mp:*:*) +- echo craynv-cray-unicosmp"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/' +- exit ;; ++ CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'` ++ GUESS=craynv-cray-unicosmp$CRAY_REL ++ ;; + F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*) + FUJITSU_PROC=`uname -m | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz` + FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'` + FUJITSU_REL=`echo "$UNAME_RELEASE" | sed -e 's/ /_/'` +- echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" +- exit ;; ++ GUESS=${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL} ++ ;; + 5000:UNIX_System_V:4.*:*) + FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'` + FUJITSU_REL=`echo "$UNAME_RELEASE" | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/ /_/'` +- echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" +- exit ;; ++ GUESS=sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL} ++ ;; + i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*) +- echo "$UNAME_MACHINE"-pc-bsdi"$UNAME_RELEASE" +- exit ;; ++ GUESS=$UNAME_MACHINE-pc-bsdi$UNAME_RELEASE ++ ;; + sparc*:BSD/OS:*:*) +- echo sparc-unknown-bsdi"$UNAME_RELEASE" +- exit ;; ++ GUESS=sparc-unknown-bsdi$UNAME_RELEASE ++ ;; + *:BSD/OS:*:*) +- echo "$UNAME_MACHINE"-unknown-bsdi"$UNAME_RELEASE" +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-bsdi$UNAME_RELEASE ++ ;; + arm:FreeBSD:*:*) + UNAME_PROCESSOR=`uname -p` + set_cc_for_build + if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \ + | grep -q __ARM_PCS_VFP + then +- echo "${UNAME_PROCESSOR}"-unknown-freebsd"`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`"-gnueabi ++ FREEBSD_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'` ++ GUESS=$UNAME_PROCESSOR-unknown-freebsd$FREEBSD_REL-gnueabi + else +- echo "${UNAME_PROCESSOR}"-unknown-freebsd"`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`"-gnueabihf ++ FREEBSD_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'` ++ GUESS=$UNAME_PROCESSOR-unknown-freebsd$FREEBSD_REL-gnueabihf + fi +- exit ;; ++ ;; + *:FreeBSD:*:*) +- UNAME_PROCESSOR=`/usr/bin/uname -p` +- case "$UNAME_PROCESSOR" in ++ UNAME_PROCESSOR=`uname -p` ++ case $UNAME_PROCESSOR in + amd64) + UNAME_PROCESSOR=x86_64 ;; + i386) + UNAME_PROCESSOR=i586 ;; + esac +- echo "$UNAME_PROCESSOR"-unknown-freebsd"`echo "$UNAME_RELEASE"|sed -e 's/[-(].*//'`" +- exit ;; ++ FREEBSD_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'` ++ GUESS=$UNAME_PROCESSOR-unknown-freebsd$FREEBSD_REL ++ ;; + i*:CYGWIN*:*) +- echo "$UNAME_MACHINE"-pc-cygwin +- exit ;; ++ GUESS=$UNAME_MACHINE-pc-cygwin ++ ;; + *:MINGW64*:*) +- echo "$UNAME_MACHINE"-pc-mingw64 +- exit ;; ++ GUESS=$UNAME_MACHINE-pc-mingw64 ++ ;; + *:MINGW*:*) +- echo "$UNAME_MACHINE"-pc-mingw32 +- exit ;; ++ GUESS=$UNAME_MACHINE-pc-mingw32 ++ ;; + *:MSYS*:*) +- echo "$UNAME_MACHINE"-pc-msys +- exit ;; ++ GUESS=$UNAME_MACHINE-pc-msys ++ ;; + i*:PW*:*) +- echo "$UNAME_MACHINE"-pc-pw32 +- exit ;; ++ GUESS=$UNAME_MACHINE-pc-pw32 ++ ;; ++ *:SerenityOS:*:*) ++ GUESS=$UNAME_MACHINE-pc-serenity ++ ;; + *:Interix*:*) +- case "$UNAME_MACHINE" in ++ case $UNAME_MACHINE in + x86) +- echo i586-pc-interix"$UNAME_RELEASE" +- exit ;; ++ GUESS=i586-pc-interix$UNAME_RELEASE ++ ;; + authenticamd | genuineintel | EM64T) +- echo x86_64-unknown-interix"$UNAME_RELEASE" +- exit ;; ++ GUESS=x86_64-unknown-interix$UNAME_RELEASE ++ ;; + IA64) +- echo ia64-unknown-interix"$UNAME_RELEASE" +- exit ;; ++ GUESS=ia64-unknown-interix$UNAME_RELEASE ++ ;; + esac ;; + i*:UWIN*:*) +- echo "$UNAME_MACHINE"-pc-uwin +- exit ;; ++ GUESS=$UNAME_MACHINE-pc-uwin ++ ;; + amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*) +- echo x86_64-pc-cygwin +- exit ;; ++ GUESS=x86_64-pc-cygwin ++ ;; + prep*:SunOS:5.*:*) +- echo powerpcle-unknown-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`" +- exit ;; ++ SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'` ++ GUESS=powerpcle-unknown-solaris2$SUN_REL ++ ;; + *:GNU:*:*) + # the GNU system +- echo "`echo "$UNAME_MACHINE"|sed -e 's,[-/].*$,,'`-unknown-$LIBC`echo "$UNAME_RELEASE"|sed -e 's,/.*$,,'`" +- exit ;; ++ GNU_ARCH=`echo "$UNAME_MACHINE" | sed -e 's,[-/].*$,,'` ++ GNU_REL=`echo "$UNAME_RELEASE" | sed -e 's,/.*$,,'` ++ GUESS=$GNU_ARCH-unknown-$LIBC$GNU_REL ++ ;; + *:GNU/*:*:*) + # other systems with GNU libc and userland +- echo "$UNAME_MACHINE-unknown-`echo "$UNAME_SYSTEM" | sed 's,^[^/]*/,,' | tr "[:upper:]" "[:lower:]"``echo "$UNAME_RELEASE"|sed -e 's/[-(].*//'`-$LIBC" +- exit ;; ++ GNU_SYS=`echo "$UNAME_SYSTEM" | sed 's,^[^/]*/,,' | tr "[:upper:]" "[:lower:]"` ++ GNU_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'` ++ GUESS=$UNAME_MACHINE-unknown-$GNU_SYS$GNU_REL-$LIBC ++ ;; ++ x86_64:[Mm]anagarm:*:*|i?86:[Mm]anagarm:*:*) ++ GUESS="$UNAME_MACHINE-pc-managarm-mlibc" ++ ;; ++ *:[Mm]anagarm:*:*) ++ GUESS="$UNAME_MACHINE-unknown-managarm-mlibc" ++ ;; + *:Minix:*:*) +- echo "$UNAME_MACHINE"-unknown-minix +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-minix ++ ;; + aarch64:Linux:*:*) +- echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" +- exit ;; ++ set_cc_for_build ++ CPU=$UNAME_MACHINE ++ LIBCABI=$LIBC ++ if test "$CC_FOR_BUILD" != no_compiler_found; then ++ ABI=64 ++ sed 's/^ //' << EOF > "$dummy.c" ++ #ifdef __ARM_EABI__ ++ #ifdef __ARM_PCS_VFP ++ ABI=eabihf ++ #else ++ ABI=eabi ++ #endif ++ #endif ++EOF ++ cc_set_abi=`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^ABI' | sed 's, ,,g'` ++ eval "$cc_set_abi" ++ case $ABI in ++ eabi | eabihf) CPU=armv8l; LIBCABI=$LIBC$ABI ;; ++ esac ++ fi ++ GUESS=$CPU-unknown-linux-$LIBCABI ++ ;; + aarch64_be:Linux:*:*) + UNAME_MACHINE=aarch64_be +- echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ++ ;; + alpha:Linux:*:*) + case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' /proc/cpuinfo 2>/dev/null` in + EV5) UNAME_MACHINE=alphaev5 ;; +@@ -935,60 +1020,72 @@ EOF + esac + objdump --private-headers /bin/sh | grep -q ld.so.1 + if test "$?" = 0 ; then LIBC=gnulibc1 ; fi +- echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" +- exit ;; +- arc:Linux:*:* | arceb:Linux:*:*) +- echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ++ ;; ++ arc:Linux:*:* | arceb:Linux:*:* | arc32:Linux:*:* | arc64:Linux:*:*) ++ GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ++ ;; + arm*:Linux:*:*) + set_cc_for_build + if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \ + | grep -q __ARM_EABI__ + then +- echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" ++ GUESS=$UNAME_MACHINE-unknown-linux-$LIBC + else + if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \ + | grep -q __ARM_PCS_VFP + then +- echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"eabi ++ GUESS=$UNAME_MACHINE-unknown-linux-${LIBC}eabi + else +- echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"eabihf ++ GUESS=$UNAME_MACHINE-unknown-linux-${LIBC}eabihf + fi + fi +- exit ;; ++ ;; + avr32*:Linux:*:*) +- echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ++ ;; + cris:Linux:*:*) +- echo "$UNAME_MACHINE"-axis-linux-"$LIBC" +- exit ;; ++ GUESS=$UNAME_MACHINE-axis-linux-$LIBC ++ ;; + crisv32:Linux:*:*) +- echo "$UNAME_MACHINE"-axis-linux-"$LIBC" +- exit ;; ++ GUESS=$UNAME_MACHINE-axis-linux-$LIBC ++ ;; + e2k:Linux:*:*) +- echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ++ ;; + frv:Linux:*:*) +- echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ++ ;; + hexagon:Linux:*:*) +- echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ++ ;; + i*86:Linux:*:*) +- echo "$UNAME_MACHINE"-pc-linux-"$LIBC" +- exit ;; ++ GUESS=$UNAME_MACHINE-pc-linux-$LIBC ++ ;; + ia64:Linux:*:*) +- echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ++ ;; + k1om:Linux:*:*) +- echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ++ ;; ++ kvx:Linux:*:*) ++ GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ++ ;; ++ kvx:cos:*:*) ++ GUESS=$UNAME_MACHINE-unknown-cos ++ ;; ++ kvx:mbr:*:*) ++ GUESS=$UNAME_MACHINE-unknown-mbr ++ ;; ++ loongarch32:Linux:*:* | loongarch64:Linux:*:*) ++ GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ++ ;; + m32r*:Linux:*:*) +- echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ++ ;; + m68*:Linux:*:*) +- echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ++ ;; + mips:Linux:*:* | mips64:Linux:*:*) + set_cc_for_build + IS_GLIBC=0 +@@ -1033,123 +1130,135 @@ EOF + #endif + #endif + EOF +- eval "`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^CPU\|^MIPS_ENDIAN\|^LIBCABI'`" ++ cc_set_vars=`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^CPU\|^MIPS_ENDIAN\|^LIBCABI'` ++ eval "$cc_set_vars" + test "x$CPU" != x && { echo "$CPU${MIPS_ENDIAN}-unknown-linux-$LIBCABI"; exit; } + ;; + mips64el:Linux:*:*) +- echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ++ ;; + openrisc*:Linux:*:*) +- echo or1k-unknown-linux-"$LIBC" +- exit ;; ++ GUESS=or1k-unknown-linux-$LIBC ++ ;; + or32:Linux:*:* | or1k*:Linux:*:*) +- echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ++ ;; + padre:Linux:*:*) +- echo sparc-unknown-linux-"$LIBC" +- exit ;; ++ GUESS=sparc-unknown-linux-$LIBC ++ ;; + parisc64:Linux:*:* | hppa64:Linux:*:*) +- echo hppa64-unknown-linux-"$LIBC" +- exit ;; ++ GUESS=hppa64-unknown-linux-$LIBC ++ ;; + parisc:Linux:*:* | hppa:Linux:*:*) + # Look for CPU level + case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in +- PA7*) echo hppa1.1-unknown-linux-"$LIBC" ;; +- PA8*) echo hppa2.0-unknown-linux-"$LIBC" ;; +- *) echo hppa-unknown-linux-"$LIBC" ;; ++ PA7*) GUESS=hppa1.1-unknown-linux-$LIBC ;; ++ PA8*) GUESS=hppa2.0-unknown-linux-$LIBC ;; ++ *) GUESS=hppa-unknown-linux-$LIBC ;; + esac +- exit ;; ++ ;; + ppc64:Linux:*:*) +- echo powerpc64-unknown-linux-"$LIBC" +- exit ;; ++ GUESS=powerpc64-unknown-linux-$LIBC ++ ;; + ppc:Linux:*:*) +- echo powerpc-unknown-linux-"$LIBC" +- exit ;; ++ GUESS=powerpc-unknown-linux-$LIBC ++ ;; + ppc64le:Linux:*:*) +- echo powerpc64le-unknown-linux-"$LIBC" +- exit ;; ++ GUESS=powerpc64le-unknown-linux-$LIBC ++ ;; + ppcle:Linux:*:*) +- echo powerpcle-unknown-linux-"$LIBC" +- exit ;; +- riscv32:Linux:*:* | riscv64:Linux:*:*) +- echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" +- exit ;; ++ GUESS=powerpcle-unknown-linux-$LIBC ++ ;; ++ riscv32:Linux:*:* | riscv32be:Linux:*:* | riscv64:Linux:*:* | riscv64be:Linux:*:*) ++ GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ++ ;; + s390:Linux:*:* | s390x:Linux:*:*) +- echo "$UNAME_MACHINE"-ibm-linux-"$LIBC" +- exit ;; ++ GUESS=$UNAME_MACHINE-ibm-linux-$LIBC ++ ;; + sh64*:Linux:*:*) +- echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ++ ;; + sh*:Linux:*:*) +- echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ++ ;; + sparc:Linux:*:* | sparc64:Linux:*:*) +- echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ++ ;; + tile*:Linux:*:*) +- echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ++ ;; + vax:Linux:*:*) +- echo "$UNAME_MACHINE"-dec-linux-"$LIBC" +- exit ;; ++ GUESS=$UNAME_MACHINE-dec-linux-$LIBC ++ ;; + x86_64:Linux:*:*) + set_cc_for_build ++ CPU=$UNAME_MACHINE + LIBCABI=$LIBC + if test "$CC_FOR_BUILD" != no_compiler_found; then +- if (echo '#ifdef __ILP32__'; echo IS_X32; echo '#endif') | \ +- (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \ +- grep IS_X32 >/dev/null +- then +- LIBCABI="$LIBC"x32 +- fi ++ ABI=64 ++ sed 's/^ //' << EOF > "$dummy.c" ++ #ifdef __i386__ ++ ABI=x86 ++ #else ++ #ifdef __ILP32__ ++ ABI=x32 ++ #endif ++ #endif ++EOF ++ cc_set_abi=`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^ABI' | sed 's, ,,g'` ++ eval "$cc_set_abi" ++ case $ABI in ++ x86) CPU=i686 ;; ++ x32) LIBCABI=${LIBC}x32 ;; ++ esac + fi +- echo "$UNAME_MACHINE"-pc-linux-"$LIBCABI" +- exit ;; ++ GUESS=$CPU-pc-linux-$LIBCABI ++ ;; + xtensa*:Linux:*:*) +- echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-linux-$LIBC ++ ;; + i*86:DYNIX/ptx:4*:*) + # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there. + # earlier versions are messed up and put the nodename in both + # sysname and nodename. +- echo i386-sequent-sysv4 +- exit ;; ++ GUESS=i386-sequent-sysv4 ++ ;; + i*86:UNIX_SV:4.2MP:2.*) + # Unixware is an offshoot of SVR4, but it has its own version + # number series starting with 2... + # I am not positive that other SVR4 systems won't match this, + # I just have to hope. -- rms. + # Use sysv4.2uw... so that sysv4* matches it. +- echo "$UNAME_MACHINE"-pc-sysv4.2uw"$UNAME_VERSION" +- exit ;; ++ GUESS=$UNAME_MACHINE-pc-sysv4.2uw$UNAME_VERSION ++ ;; + i*86:OS/2:*:*) +- # If we were able to find `uname', then EMX Unix compatibility ++ # If we were able to find 'uname', then EMX Unix compatibility + # is probably installed. +- echo "$UNAME_MACHINE"-pc-os2-emx +- exit ;; ++ GUESS=$UNAME_MACHINE-pc-os2-emx ++ ;; + i*86:XTS-300:*:STOP) +- echo "$UNAME_MACHINE"-unknown-stop +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-stop ++ ;; + i*86:atheos:*:*) +- echo "$UNAME_MACHINE"-unknown-atheos +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-atheos ++ ;; + i*86:syllable:*:*) +- echo "$UNAME_MACHINE"-pc-syllable +- exit ;; ++ GUESS=$UNAME_MACHINE-pc-syllable ++ ;; + i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*) +- echo i386-unknown-lynxos"$UNAME_RELEASE" +- exit ;; ++ GUESS=i386-unknown-lynxos$UNAME_RELEASE ++ ;; + i*86:*DOS:*:*) +- echo "$UNAME_MACHINE"-pc-msdosdjgpp +- exit ;; ++ GUESS=$UNAME_MACHINE-pc-msdosdjgpp ++ ;; + i*86:*:4.*:*) + UNAME_REL=`echo "$UNAME_RELEASE" | sed 's/\/MP$//'` + if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then +- echo "$UNAME_MACHINE"-univel-sysv"$UNAME_REL" ++ GUESS=$UNAME_MACHINE-univel-sysv$UNAME_REL + else +- echo "$UNAME_MACHINE"-pc-sysv"$UNAME_REL" ++ GUESS=$UNAME_MACHINE-pc-sysv$UNAME_REL + fi +- exit ;; ++ ;; + i*86:*:5:[678]*) + # UnixWare 7.x, OpenUNIX and OpenServer 6. + case `/bin/uname -X | grep "^Machine"` in +@@ -1157,12 +1266,12 @@ EOF + *Pentium) UNAME_MACHINE=i586 ;; + *Pent*|*Celeron) UNAME_MACHINE=i686 ;; + esac +- echo "$UNAME_MACHINE-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION}" +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION} ++ ;; + i*86:*:3.2:*) + if test -f /usr/options/cb.name; then + UNAME_REL=`sed -n 's/.*Version //p' /dev/null >/dev/null ; then + UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')` + (/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486 +@@ -1172,11 +1281,11 @@ EOF + && UNAME_MACHINE=i686 + (/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \ + && UNAME_MACHINE=i686 +- echo "$UNAME_MACHINE"-pc-sco"$UNAME_REL" ++ GUESS=$UNAME_MACHINE-pc-sco$UNAME_REL + else +- echo "$UNAME_MACHINE"-pc-sysv32 ++ GUESS=$UNAME_MACHINE-pc-sysv32 + fi +- exit ;; ++ ;; + pc:*:*:*) + # Left here for compatibility: + # uname -m prints for DJGPP always 'pc', but it prints nothing about +@@ -1184,31 +1293,31 @@ EOF + # Note: whatever this is, it MUST be the same as what config.sub + # prints for the "djgpp" host, or else GDB configure will decide that + # this is a cross-build. +- echo i586-pc-msdosdjgpp +- exit ;; ++ GUESS=i586-pc-msdosdjgpp ++ ;; + Intel:Mach:3*:*) +- echo i386-pc-mach3 +- exit ;; ++ GUESS=i386-pc-mach3 ++ ;; + paragon:*:*:*) +- echo i860-intel-osf1 +- exit ;; ++ GUESS=i860-intel-osf1 ++ ;; + i860:*:4.*:*) # i860-SVR4 + if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then +- echo i860-stardent-sysv"$UNAME_RELEASE" # Stardent Vistra i860-SVR4 ++ GUESS=i860-stardent-sysv$UNAME_RELEASE # Stardent Vistra i860-SVR4 + else # Add other i860-SVR4 vendors below as they are discovered. +- echo i860-unknown-sysv"$UNAME_RELEASE" # Unknown i860-SVR4 ++ GUESS=i860-unknown-sysv$UNAME_RELEASE # Unknown i860-SVR4 + fi +- exit ;; ++ ;; + mini*:CTIX:SYS*5:*) + # "miniframe" +- echo m68010-convergent-sysv +- exit ;; ++ GUESS=m68010-convergent-sysv ++ ;; + mc68k:UNIX:SYSTEM5:3.51m) +- echo m68k-convergent-sysv +- exit ;; ++ GUESS=m68k-convergent-sysv ++ ;; + M680?0:D-NIX:5.3:*) +- echo m68k-diab-dnix +- exit ;; ++ GUESS=m68k-diab-dnix ++ ;; + M68*:*:R3V[5678]*:*) + test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;; + 3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0) +@@ -1233,116 +1342,119 @@ EOF + /bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \ + && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } ;; + m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*) +- echo m68k-unknown-lynxos"$UNAME_RELEASE" +- exit ;; ++ GUESS=m68k-unknown-lynxos$UNAME_RELEASE ++ ;; + mc68030:UNIX_System_V:4.*:*) +- echo m68k-atari-sysv4 +- exit ;; ++ GUESS=m68k-atari-sysv4 ++ ;; + TSUNAMI:LynxOS:2.*:*) +- echo sparc-unknown-lynxos"$UNAME_RELEASE" +- exit ;; ++ GUESS=sparc-unknown-lynxos$UNAME_RELEASE ++ ;; + rs6000:LynxOS:2.*:*) +- echo rs6000-unknown-lynxos"$UNAME_RELEASE" +- exit ;; ++ GUESS=rs6000-unknown-lynxos$UNAME_RELEASE ++ ;; + PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*) +- echo powerpc-unknown-lynxos"$UNAME_RELEASE" +- exit ;; ++ GUESS=powerpc-unknown-lynxos$UNAME_RELEASE ++ ;; + SM[BE]S:UNIX_SV:*:*) +- echo mips-dde-sysv"$UNAME_RELEASE" +- exit ;; ++ GUESS=mips-dde-sysv$UNAME_RELEASE ++ ;; + RM*:ReliantUNIX-*:*:*) +- echo mips-sni-sysv4 +- exit ;; ++ GUESS=mips-sni-sysv4 ++ ;; + RM*:SINIX-*:*:*) +- echo mips-sni-sysv4 +- exit ;; ++ GUESS=mips-sni-sysv4 ++ ;; + *:SINIX-*:*:*) + if uname -p 2>/dev/null >/dev/null ; then + UNAME_MACHINE=`(uname -p) 2>/dev/null` +- echo "$UNAME_MACHINE"-sni-sysv4 ++ GUESS=$UNAME_MACHINE-sni-sysv4 + else +- echo ns32k-sni-sysv ++ GUESS=ns32k-sni-sysv + fi +- exit ;; +- PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort ++ ;; ++ PENTIUM:*:4.0*:*) # Unisys 'ClearPath HMP IX 4000' SVR4/MP effort + # says +- echo i586-unisys-sysv4 +- exit ;; ++ GUESS=i586-unisys-sysv4 ++ ;; + *:UNIX_System_V:4*:FTX*) + # From Gerald Hewes . + # How about differentiating between stratus architectures? -djm +- echo hppa1.1-stratus-sysv4 +- exit ;; ++ GUESS=hppa1.1-stratus-sysv4 ++ ;; + *:*:*:FTX*) + # From seanf@swdc.stratus.com. +- echo i860-stratus-sysv4 +- exit ;; ++ GUESS=i860-stratus-sysv4 ++ ;; + i*86:VOS:*:*) + # From Paul.Green@stratus.com. +- echo "$UNAME_MACHINE"-stratus-vos +- exit ;; ++ GUESS=$UNAME_MACHINE-stratus-vos ++ ;; + *:VOS:*:*) + # From Paul.Green@stratus.com. +- echo hppa1.1-stratus-vos +- exit ;; ++ GUESS=hppa1.1-stratus-vos ++ ;; + mc68*:A/UX:*:*) +- echo m68k-apple-aux"$UNAME_RELEASE" +- exit ;; ++ GUESS=m68k-apple-aux$UNAME_RELEASE ++ ;; + news*:NEWS-OS:6*:*) +- echo mips-sony-newsos6 +- exit ;; ++ GUESS=mips-sony-newsos6 ++ ;; + R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*) + if test -d /usr/nec; then +- echo mips-nec-sysv"$UNAME_RELEASE" ++ GUESS=mips-nec-sysv$UNAME_RELEASE + else +- echo mips-unknown-sysv"$UNAME_RELEASE" ++ GUESS=mips-unknown-sysv$UNAME_RELEASE + fi +- exit ;; ++ ;; + BeBox:BeOS:*:*) # BeOS running on hardware made by Be, PPC only. +- echo powerpc-be-beos +- exit ;; ++ GUESS=powerpc-be-beos ++ ;; + BeMac:BeOS:*:*) # BeOS running on Mac or Mac clone, PPC only. +- echo powerpc-apple-beos +- exit ;; ++ GUESS=powerpc-apple-beos ++ ;; + BePC:BeOS:*:*) # BeOS running on Intel PC compatible. +- echo i586-pc-beos +- exit ;; ++ GUESS=i586-pc-beos ++ ;; + BePC:Haiku:*:*) # Haiku running on Intel PC compatible. +- echo i586-pc-haiku +- exit ;; +- x86_64:Haiku:*:*) +- echo x86_64-unknown-haiku +- exit ;; ++ GUESS=i586-pc-haiku ++ ;; ++ ppc:Haiku:*:*) # Haiku running on Apple PowerPC ++ GUESS=powerpc-apple-haiku ++ ;; ++ *:Haiku:*:*) # Haiku modern gcc (not bound by BeOS compat) ++ GUESS=$UNAME_MACHINE-unknown-haiku ++ ;; + SX-4:SUPER-UX:*:*) +- echo sx4-nec-superux"$UNAME_RELEASE" +- exit ;; ++ GUESS=sx4-nec-superux$UNAME_RELEASE ++ ;; + SX-5:SUPER-UX:*:*) +- echo sx5-nec-superux"$UNAME_RELEASE" +- exit ;; ++ GUESS=sx5-nec-superux$UNAME_RELEASE ++ ;; + SX-6:SUPER-UX:*:*) +- echo sx6-nec-superux"$UNAME_RELEASE" +- exit ;; ++ GUESS=sx6-nec-superux$UNAME_RELEASE ++ ;; + SX-7:SUPER-UX:*:*) +- echo sx7-nec-superux"$UNAME_RELEASE" +- exit ;; ++ GUESS=sx7-nec-superux$UNAME_RELEASE ++ ;; + SX-8:SUPER-UX:*:*) +- echo sx8-nec-superux"$UNAME_RELEASE" +- exit ;; ++ GUESS=sx8-nec-superux$UNAME_RELEASE ++ ;; + SX-8R:SUPER-UX:*:*) +- echo sx8r-nec-superux"$UNAME_RELEASE" +- exit ;; ++ GUESS=sx8r-nec-superux$UNAME_RELEASE ++ ;; + SX-ACE:SUPER-UX:*:*) +- echo sxace-nec-superux"$UNAME_RELEASE" +- exit ;; ++ GUESS=sxace-nec-superux$UNAME_RELEASE ++ ;; + Power*:Rhapsody:*:*) +- echo powerpc-apple-rhapsody"$UNAME_RELEASE" +- exit ;; ++ GUESS=powerpc-apple-rhapsody$UNAME_RELEASE ++ ;; + *:Rhapsody:*:*) +- echo "$UNAME_MACHINE"-apple-rhapsody"$UNAME_RELEASE" +- exit ;; ++ GUESS=$UNAME_MACHINE-apple-rhapsody$UNAME_RELEASE ++ ;; + arm64:Darwin:*:*) +- echo aarch64-apple-darwin"$UNAME_RELEASE" +- exit ;; ++ GUESS=aarch64-apple-darwin$UNAME_RELEASE ++ ;; + *:Darwin:*:*) + UNAME_PROCESSOR=`uname -p` + case $UNAME_PROCESSOR in +@@ -1378,109 +1490,122 @@ EOF + # uname -m returns i386 or x86_64 + UNAME_PROCESSOR=$UNAME_MACHINE + fi +- echo "$UNAME_PROCESSOR"-apple-darwin"$UNAME_RELEASE" +- exit ;; ++ GUESS=$UNAME_PROCESSOR-apple-darwin$UNAME_RELEASE ++ ;; + *:procnto*:*:* | *:QNX:[0123456789]*:*) + UNAME_PROCESSOR=`uname -p` + if test "$UNAME_PROCESSOR" = x86; then + UNAME_PROCESSOR=i386 + UNAME_MACHINE=pc + fi +- echo "$UNAME_PROCESSOR"-"$UNAME_MACHINE"-nto-qnx"$UNAME_RELEASE" +- exit ;; ++ GUESS=$UNAME_PROCESSOR-$UNAME_MACHINE-nto-qnx$UNAME_RELEASE ++ ;; + *:QNX:*:4*) +- echo i386-pc-qnx +- exit ;; ++ GUESS=i386-pc-qnx ++ ;; + NEO-*:NONSTOP_KERNEL:*:*) +- echo neo-tandem-nsk"$UNAME_RELEASE" +- exit ;; ++ GUESS=neo-tandem-nsk$UNAME_RELEASE ++ ;; + NSE-*:NONSTOP_KERNEL:*:*) +- echo nse-tandem-nsk"$UNAME_RELEASE" +- exit ;; ++ GUESS=nse-tandem-nsk$UNAME_RELEASE ++ ;; + NSR-*:NONSTOP_KERNEL:*:*) +- echo nsr-tandem-nsk"$UNAME_RELEASE" +- exit ;; ++ GUESS=nsr-tandem-nsk$UNAME_RELEASE ++ ;; + NSV-*:NONSTOP_KERNEL:*:*) +- echo nsv-tandem-nsk"$UNAME_RELEASE" +- exit ;; ++ GUESS=nsv-tandem-nsk$UNAME_RELEASE ++ ;; + NSX-*:NONSTOP_KERNEL:*:*) +- echo nsx-tandem-nsk"$UNAME_RELEASE" +- exit ;; ++ GUESS=nsx-tandem-nsk$UNAME_RELEASE ++ ;; + *:NonStop-UX:*:*) +- echo mips-compaq-nonstopux +- exit ;; ++ GUESS=mips-compaq-nonstopux ++ ;; + BS2000:POSIX*:*:*) +- echo bs2000-siemens-sysv +- exit ;; ++ GUESS=bs2000-siemens-sysv ++ ;; + DS/*:UNIX_System_V:*:*) +- echo "$UNAME_MACHINE"-"$UNAME_SYSTEM"-"$UNAME_RELEASE" +- exit ;; ++ GUESS=$UNAME_MACHINE-$UNAME_SYSTEM-$UNAME_RELEASE ++ ;; + *:Plan9:*:*) + # "uname -m" is not consistent, so use $cputype instead. 386 + # is converted to i386 for consistency with other x86 + # operating systems. +- # shellcheck disable=SC2154 +- if test "$cputype" = 386; then ++ if test "${cputype-}" = 386; then + UNAME_MACHINE=i386 +- else +- UNAME_MACHINE="$cputype" ++ elif test "x${cputype-}" != x; then ++ UNAME_MACHINE=$cputype + fi +- echo "$UNAME_MACHINE"-unknown-plan9 +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-plan9 ++ ;; + *:TOPS-10:*:*) +- echo pdp10-unknown-tops10 +- exit ;; ++ GUESS=pdp10-unknown-tops10 ++ ;; + *:TENEX:*:*) +- echo pdp10-unknown-tenex +- exit ;; ++ GUESS=pdp10-unknown-tenex ++ ;; + KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*) +- echo pdp10-dec-tops20 +- exit ;; ++ GUESS=pdp10-dec-tops20 ++ ;; + XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*) +- echo pdp10-xkl-tops20 +- exit ;; ++ GUESS=pdp10-xkl-tops20 ++ ;; + *:TOPS-20:*:*) +- echo pdp10-unknown-tops20 +- exit ;; ++ GUESS=pdp10-unknown-tops20 ++ ;; + *:ITS:*:*) +- echo pdp10-unknown-its +- exit ;; ++ GUESS=pdp10-unknown-its ++ ;; + SEI:*:*:SEIUX) +- echo mips-sei-seiux"$UNAME_RELEASE" +- exit ;; ++ GUESS=mips-sei-seiux$UNAME_RELEASE ++ ;; + *:DragonFly:*:*) +- echo "$UNAME_MACHINE"-unknown-dragonfly"`echo "$UNAME_RELEASE"|sed -e 's/[-(].*//'`" +- exit ;; ++ DRAGONFLY_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'` ++ GUESS=$UNAME_MACHINE-unknown-dragonfly$DRAGONFLY_REL ++ ;; + *:*VMS:*:*) + UNAME_MACHINE=`(uname -p) 2>/dev/null` +- case "$UNAME_MACHINE" in +- A*) echo alpha-dec-vms ; exit ;; +- I*) echo ia64-dec-vms ; exit ;; +- V*) echo vax-dec-vms ; exit ;; ++ case $UNAME_MACHINE in ++ A*) GUESS=alpha-dec-vms ;; ++ I*) GUESS=ia64-dec-vms ;; ++ V*) GUESS=vax-dec-vms ;; + esac ;; + *:XENIX:*:SysV) +- echo i386-pc-xenix +- exit ;; ++ GUESS=i386-pc-xenix ++ ;; + i*86:skyos:*:*) +- echo "$UNAME_MACHINE"-pc-skyos"`echo "$UNAME_RELEASE" | sed -e 's/ .*$//'`" +- exit ;; ++ SKYOS_REL=`echo "$UNAME_RELEASE" | sed -e 's/ .*$//'` ++ GUESS=$UNAME_MACHINE-pc-skyos$SKYOS_REL ++ ;; + i*86:rdos:*:*) +- echo "$UNAME_MACHINE"-pc-rdos +- exit ;; +- i*86:AROS:*:*) +- echo "$UNAME_MACHINE"-pc-aros +- exit ;; ++ GUESS=$UNAME_MACHINE-pc-rdos ++ ;; ++ i*86:Fiwix:*:*) ++ GUESS=$UNAME_MACHINE-pc-fiwix ++ ;; ++ *:AROS:*:*) ++ GUESS=$UNAME_MACHINE-unknown-aros ++ ;; + x86_64:VMkernel:*:*) +- echo "$UNAME_MACHINE"-unknown-esx +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-esx ++ ;; + amd64:Isilon\ OneFS:*:*) +- echo x86_64-unknown-onefs +- exit ;; ++ GUESS=x86_64-unknown-onefs ++ ;; + *:Unleashed:*:*) +- echo "$UNAME_MACHINE"-unknown-unleashed"$UNAME_RELEASE" +- exit ;; ++ GUESS=$UNAME_MACHINE-unknown-unleashed$UNAME_RELEASE ++ ;; ++ *:Ironclad:*:*) ++ GUESS=$UNAME_MACHINE-unknown-ironclad ++ ;; + esac + ++# Do we have a guess based on uname results? ++if test "x$GUESS" != x; then ++ echo "$GUESS" ++ exit ++fi ++ + # No uname command or uname output not recognized. + set_cc_for_build + cat > "$dummy.c" </dev/null && SYSTEM_NAME=`$dummy` && ++$CC_FOR_BUILD -o "$dummy" "$dummy.c" 2>/dev/null && SYSTEM_NAME=`"$dummy"` && + { echo "$SYSTEM_NAME"; exit; } + + # Apollos put the system type in the environment. +@@ -1620,7 +1745,7 @@ test -d /usr/apollo && { echo "$ISP-apollo-$SYSTYPE"; exit; } + + echo "$0: unable to guess system type" >&2 + +-case "$UNAME_MACHINE:$UNAME_SYSTEM" in ++case $UNAME_MACHINE:$UNAME_SYSTEM in + mips:Linux | mips64:Linux) + # If we got here on MIPS GNU/Linux, output extra information. + cat >&2 <&2 <&2 ++ echo "Invalid configuration '$1': more than four components" >&2 + exit 1 + ;; + *-*-*-*) +@@ -134,7 +145,8 @@ case $1 in + nto-qnx* | linux-* | uclinux-uclibc* \ + | uclinux-gnu* | kfreebsd*-gnu* | knetbsd*-gnu* | netbsd*-gnu* \ + | netbsd*-eabi* | kopensolaris*-gnu* | cloudabi*-eabi* \ +- | storm-chaos* | os2-emx* | rtmk-nova*) ++ | storm-chaos* | os2-emx* | rtmk-nova* | managarm-* \ ++ | windows-* ) + basic_machine=$field1 + basic_os=$maybe_os + ;; +@@ -163,6 +175,10 @@ case $1 in + basic_machine=$field1 + basic_os=$field2 + ;; ++ zephyr*) ++ basic_machine=$field1-unknown ++ basic_os=$field2 ++ ;; + # Manufacturers + dec* | mips* | sequent* | encore* | pc533* | sgi* | sony* \ + | att* | 7300* | 3300* | delta* | motorola* | sun[234]* \ +@@ -922,11 +938,13 @@ case $basic_machine in + + *-*) + # shellcheck disable=SC2162 ++ saved_IFS=$IFS + IFS="-" read cpu vendor <&2 ++ echo "Invalid configuration '$1': machine '$cpu-$vendor' not recognized" 1>&2 + exit 1 + ;; + esac +@@ -1278,34 +1287,45 @@ esac + + # Decode manufacturer-specific aliases for certain operating systems. + +-if test x$basic_os != x ++if test x"$basic_os" != x + then + +-# First recognize some ad-hoc caes, or perhaps split kernel-os, or else just ++# First recognize some ad-hoc cases, or perhaps split kernel-os, or else just + # set os. ++obj= + case $basic_os in + gnu/linux*) + kernel=linux +- os=`echo $basic_os | sed -e 's|gnu/linux|gnu|'` ++ os=`echo "$basic_os" | sed -e 's|gnu/linux|gnu|'` ++ ;; ++ os2-emx) ++ kernel=os2 ++ os=`echo "$basic_os" | sed -e 's|os2-emx|emx|'` + ;; + nto-qnx*) + kernel=nto +- os=`echo $basic_os | sed -e 's|nto-qnx|qnx|'` ++ os=`echo "$basic_os" | sed -e 's|nto-qnx|qnx|'` + ;; + *-*) + # shellcheck disable=SC2162 ++ saved_IFS=$IFS + IFS="-" read kernel os <&2 ++ fi ++ ;; ++ *) ++ echo "Invalid configuration '$1': OS '$os' not recognized" 1>&2 ++ exit 1 ++ ;; ++esac ++ ++case $obj in ++ aout* | coff* | elf* | pe*) ++ ;; ++ '') ++ # empty is fine ++ ;; + *) +- echo Invalid configuration \`"$1"\': OS \`"$os"\' not recognized 1>&2 ++ echo "Invalid configuration '$1': Machine code format '$obj' not recognized" 1>&2 ++ exit 1 ++ ;; ++esac ++ ++# Here we handle the constraint that a (synthetic) cpu and os are ++# valid only in combination with each other and nowhere else. ++case $cpu-$os in ++ # The "javascript-unknown-ghcjs" triple is used by GHC; we ++ # accept it here in order to tolerate that, but reject any ++ # variations. ++ javascript-ghcjs) ++ ;; ++ javascript-* | *-ghcjs) ++ echo "Invalid configuration '$1': cpu '$cpu' is not valid with os '$os$obj'" 1>&2 + exit 1 + ;; + esac + + # As a final step for OS-related things, validate the OS-kernel combination + # (given a valid OS), if there is a kernel. +-case $kernel-$os in +- linux-gnu* | linux-dietlibc* | linux-android* | linux-newlib* | linux-musl* | linux-uclibc* ) ++case $kernel-$os-$obj in ++ linux-gnu*- | linux-android*- | linux-dietlibc*- | linux-llvm*- \ ++ | linux-mlibc*- | linux-musl*- | linux-newlib*- \ ++ | linux-relibc*- | linux-uclibc*- ) + ;; +- uclinux-uclibc* ) ++ uclinux-uclibc*- ) + ;; +- -dietlibc* | -newlib* | -musl* | -uclibc* ) ++ managarm-mlibc*- | managarm-kernel*- ) ++ ;; ++ windows*-msvc*-) ++ ;; ++ -dietlibc*- | -llvm*- | -mlibc*- | -musl*- | -newlib*- | -relibc*- \ ++ | -uclibc*- ) + # These are just libc implementations, not actual OSes, and thus + # require a kernel. +- echo "Invalid configuration \`$1': libc \`$os' needs explicit kernel." 1>&2 ++ echo "Invalid configuration '$1': libc '$os' needs explicit kernel." 1>&2 + exit 1 + ;; +- kfreebsd*-gnu* | kopensolaris*-gnu*) ++ -kernel*- ) ++ echo "Invalid configuration '$1': '$os' needs explicit kernel." 1>&2 ++ exit 1 + ;; +- nto-qnx*) ++ *-kernel*- ) ++ echo "Invalid configuration '$1': '$kernel' does not support '$os'." 1>&2 ++ exit 1 + ;; +- *-eabi* | *-gnueabi*) ++ *-msvc*- ) ++ echo "Invalid configuration '$1': '$os' needs 'windows'." 1>&2 ++ exit 1 ++ ;; ++ kfreebsd*-gnu*- | kopensolaris*-gnu*-) ++ ;; ++ vxworks-simlinux- | vxworks-simwindows- | vxworks-spe-) ++ ;; ++ nto-qnx*-) ++ ;; ++ os2-emx-) + ;; +- -*) ++ *-eabi*- | *-gnueabi*-) ++ ;; ++ none--*) ++ # None (no kernel, i.e. freestanding / bare metal), ++ # can be paired with an machine code file format ++ ;; ++ -*-) + # Blank kernel with real OS is always fine. + ;; +- *-*) +- echo "Invalid configuration \`$1': Kernel \`$kernel' not known to work with OS \`$os'." 1>&2 ++ --*) ++ # Blank kernel and OS with real machine code file format is always fine. ++ ;; ++ *-*-*) ++ echo "Invalid configuration '$1': Kernel '$kernel' not known to work with OS '$os'." 1>&2 + exit 1 + ;; + esac +@@ -1836,7 +1960,7 @@ case $vendor in + ;; + esac + +-echo "$cpu-$vendor-${kernel:+$kernel-}$os" ++echo "$cpu-$vendor${kernel:+-$kernel}${os:+-$os}${obj:+-$obj}" + exit + + # Local variables: +-- +2.43.0 + +_______________________________________________ +buildroot mailing list +buildroot@buildroot.org +https://lists.buildroot.org/mailman/listinfo/buildroot + +From git@z Thu Jan 1 00:00:00 1970 +Subject: [PATCH 2/7] package/gcc: Introduce BR2_GCC_TARGET_SIMD option +From: Jiaxun Yang +Date: Fri, 24 May 2024 20:36:36 +0100 +Message-Id: <20240524-loongarch64-v1-2-d24078d79cd5@flygoat.com> +MIME-Version: 1.0 +Content-Type: text/plain; charset="utf-8" +Content-Transfer-Encoding: 7bit + +Introduce BR2_GCC_TARGET_SIMD for gcc to handle --with-simd/-msimd +present at loongarch's gcc options. + +Signed-off-by: Jiaxun Yang +Link: https://lore.kernel.org/r/20240524-loongarch64-v1-2-d24078d79cd5@flygoat.com +--- + arch/Config.in | 6 ++++++ + arch/arch.mk | 1 + + package/gcc/gcc.mk | 4 ++++ + toolchain/toolchain-external/pkg-toolchain-external.mk | 4 ++++ + 4 files changed, 15 insertions(+) + +diff --git a/arch/Config.in b/arch/Config.in +index f39c33ef7fff..cc902446bfd9 100644 +--- a/arch/Config.in ++++ b/arch/Config.in +@@ -350,6 +350,12 @@ config BR2_GCC_TARGET_FPU + config BR2_GCC_TARGET_FLOAT_ABI + string + ++# The value of this option will be passed as --with-simd= when ++# building gcc (internal backend) or -simd= in the toolchain ++# wrapper (external toolchain) ++config BR2_GCC_TARGET_SIMD ++ string ++ + # The value of this option will be passed as --with-mode= when + # building gcc (internal backend) or -m in the toolchain + # wrapper (external toolchain) +diff --git a/arch/arch.mk b/arch/arch.mk +index 4174d33df548..4a7851a9fdce 100644 +--- a/arch/arch.mk ++++ b/arch/arch.mk +@@ -16,6 +16,7 @@ GCC_TARGET_FP32_MODE := $(call qstrip,$(BR2_GCC_TARGET_FP32_MODE)) + GCC_TARGET_CPU := $(call qstrip,$(BR2_GCC_TARGET_CPU)) + GCC_TARGET_FPU := $(call qstrip,$(BR2_GCC_TARGET_FPU)) + GCC_TARGET_FLOAT_ABI := $(call qstrip,$(BR2_GCC_TARGET_FLOAT_ABI)) ++GCC_TARGET_SIMD := $(call qstrip,$(BR2_GCC_TARGET_SIMD)) + GCC_TARGET_MODE := $(call qstrip,$(BR2_GCC_TARGET_MODE)) + + # Explicitly set LD's "max-page-size" instead of relying on some defaults +diff --git a/package/gcc/gcc.mk b/package/gcc/gcc.mk +index 672f9472a947..394559479ce1 100644 +--- a/package/gcc/gcc.mk ++++ b/package/gcc/gcc.mk +@@ -251,6 +251,10 @@ ifneq ($(GCC_TARGET_FLOAT_ABI),) + HOST_GCC_COMMON_CONF_OPTS += --with-float=$(GCC_TARGET_FLOAT_ABI) + endif + ++ifneq ($(GCC_TARGET_SIMD),) ++HOST_GCC_COMMON_CONF_OPTS += --with-simd=$(GCC_TARGET_SIMD) ++endif ++ + ifneq ($(GCC_TARGET_MODE),) + HOST_GCC_COMMON_CONF_OPTS += --with-mode=$(GCC_TARGET_MODE) + endif +diff --git a/toolchain/toolchain-external/pkg-toolchain-external.mk b/toolchain/toolchain-external/pkg-toolchain-external.mk +index c08bf0a65391..2c2afa76c069 100644 +--- a/toolchain/toolchain-external/pkg-toolchain-external.mk ++++ b/toolchain/toolchain-external/pkg-toolchain-external.mk +@@ -217,6 +217,10 @@ ifneq ($(GCC_TARGET_FLOAT_ABI),) + TOOLCHAIN_EXTERNAL_CFLAGS += -mfloat-abi=$(GCC_TARGET_FLOAT_ABI) + TOOLCHAIN_EXTERNAL_TOOLCHAIN_WRAPPER_ARGS += -DBR_FLOAT_ABI='"$(GCC_TARGET_FLOAT_ABI)"' + endif ++ifneq ($(GCC_TARGET_SIMD),) ++TOOLCHAIN_EXTERNAL_CFLAGS += -msimd=$(GCC_TARGET_SIMD) ++TOOLCHAIN_EXTERNAL_TOOLCHAIN_WRAPPER_ARGS += -DBR_SIMD='"$(GCC_TARGET_SIMD)"' ++endif + ifneq ($(GCC_TARGET_MODE),) + TOOLCHAIN_EXTERNAL_CFLAGS += -m$(GCC_TARGET_MODE) + TOOLCHAIN_EXTERNAL_TOOLCHAIN_WRAPPER_ARGS += -DBR_MODE='"$(GCC_TARGET_MODE)"' +-- +2.43.0 + +_______________________________________________ +buildroot mailing list +buildroot@buildroot.org +https://lists.buildroot.org/mailman/listinfo/buildroot + +From git@z Thu Jan 1 00:00:00 1970 +Subject: [PATCH 3/7] arch: Introduce LoongArch64 +From: Jiaxun Yang +Date: Fri, 24 May 2024 20:36:37 +0100 +Message-Id: <20240524-loongarch64-v1-3-d24078d79cd5@flygoat.com> +MIME-Version: 1.0 +Content-Type: text/plain; charset="utf-8" +Content-Transfer-Encoding: 7bit + +Introduce LoongArch64 at architecture level. + +Config.in.loongarch is prepared for possible loongarch32 +enablement in future. + +Signed-off-by: Jiaxun Yang +Link: https://lore.kernel.org/r/20240524-loongarch64-v1-3-d24078d79cd5@flygoat.com +--- + arch/Config.in | 13 +++++ + arch/Config.in.loongarch | 127 +++++++++++++++++++++++++++++++++++++++++++++++ + 2 files changed, 140 insertions(+) + +diff --git a/arch/Config.in b/arch/Config.in +index cc902446bfd9..504808fcbce4 100644 +--- a/arch/Config.in ++++ b/arch/Config.in +@@ -77,6 +77,15 @@ config BR2_i386 + Intel i386 architecture compatible microprocessor + http://en.wikipedia.org/wiki/I386 + ++config BR2_loongarch64 ++ bool "LoongArch64" ++ select BR2_USE_MMU ++ select BR2_ARCH_IS_64 ++ help ++ LoongArch64 is a is a 64-bit architecture developed by Loongson. ++ http://www.loongson.cn/ ++ https://en.wikipedia.org/wiki/Loongson ++ + config BR2_m68k + bool "m68k" + # MMU support is set by the subarchitecture file, arch/Config.in.m68k +@@ -380,6 +389,10 @@ if BR2_arm || BR2_armeb || BR2_aarch64 || BR2_aarch64_be + source "arch/Config.in.arm" + endif + ++if BR2_loongarch64 ++source "arch/Config.in.loongarch" ++endif ++ + if BR2_m68k + source "arch/Config.in.m68k" + endif +diff --git a/arch/Config.in.loongarch b/arch/Config.in.loongarch +new file mode 100644 +index 000000000000..f5d767a9d87d +--- /dev/null ++++ b/arch/Config.in.loongarch +@@ -0,0 +1,127 @@ ++# LoongArch CPU ++ ++choice ++ prompt "Target Architecture Variant" ++ default BR2_loongarch64_generic ++ ++config BR2_loongarch64_generic ++ bool "Generic LoongArch 64-bit" ++ depends on BR2_ARCH_IS_64 ++ select BR2_ARCH_NEEDS_GCC_AT_LEAST_12 ++ help ++ Generic LoongArch 64-bit processor. ++ ++config BR2_loongarch64_v1_0 ++ bool "LoongArch64 ISA version 1.0" ++ depends on BR2_ARCH_IS_64 ++ select BR2_ARCH_NEEDS_GCC_AT_LEAST_13 ++ help ++ LoongArch64 ISA version 1.0 processor. ++ ++config BR2_loongarch64_v1_1 ++ bool "LoongArch64 ISA version 1.1" ++ depends on BR2_ARCH_IS_64 ++ select BR2_ARCH_NEEDS_GCC_AT_LEAST_13 ++ help ++ LoongArch64 ISA version 1.1 processor. ++endchoice ++ ++choice ++ prompt "FPU Type" ++ default BR2_LOONGARCH_FPU_64 ++ ++config BR2_LOONGARCH_FPU_64 ++ bool "64" ++ help ++ Allow the use of hardware floating-point instructions for 32-bit ++ and 64-bit operations. ++ ++config BR2_LOONGARCH_FPU_32 ++ bool "32" ++ help ++ Allow the use of hardware floating-point instructions for 32-bit ++ operations only. ++ ++config BR2_LOONGARCH_FPU_NONE ++ bool "none" ++ help ++ Prevent the use of hardware floating-point instructions. ++endchoice ++ ++choice ++ prompt "SIMD Type" ++ default BR2_LOONGARCH_SIMD_NONE ++ ++config BR2_LOONGARCH_SIMD_NONE ++ bool "none" ++ help ++ Prevent the use of hardware SIMD instructions. ++ ++config BR2_LOONGARCH_SIMD_LSX ++ bool "LSX" ++ help ++ Enable generating instructions from the 128-bit LoongArch SIMD ++ Extension (LSX). ++ ++config BR2_LOONGARCH_SIMD_LASX ++ bool "LASX" ++ help ++ Enable generating instructions from the 256-bit LoongArch Advanced ++ SIMD Extension (LASX) and the 128-bit LoongArch SIMD Extension (LSX). ++endchoice ++ ++choice ++ prompt "Target ABI" ++ default BR2_LOONGARCH_ABI_LP64D if BR2_ARCH_IS_64 && BR2_LOONGARCH_FPU_64 ++ default BR2_LOONGARCH_ABI_LP64F if BR2_ARCH_IS_64 && BR2_LOONGARCH_FPU_32 ++ default BR2_LOONGARCH_ABI_LP64S if BR2_ARCH_IS_64 && BR2_LOONGARCH_SIMD_NONE ++ ++config BR2_LOONGARCH_ABI_LP64D ++ bool "lp64d" ++ depends on BR2_ARCH_IS_64 ++ depends on BR2_LOONGARCH_FPU_64 ++ ++config BR2_LOONGARCH_ABI_LP64F ++ bool "lp64f" ++ depends on BR2_ARCH_IS_64 ++ depends on BR2_LOONGARCH_FPU_64 || BR2_LOONGARCH_FPU_32 ++ ++config BR2_LOONGARCH_ABI_LP64S ++ bool "lp64d" ++ depends on BR2_ARCH_IS_64 ++endchoice ++ ++config BR2_ARCH ++ default "loongarch64" if BR2_ARCH_IS_64 ++ ++config BR2_NORMALIZED_ARCH ++ default "loongarch" ++ ++config BR2_ENDIAN ++ default "LITTLE" ++ ++config BR2_GCC_TARGET_ARCH ++ default "loongarch64" if BR2_loongarch64_generic ++ default "la64v1.0" if BR2_loongarch64_v1_0 ++ default "la64v1.1" if BR2_loongarch64_v1_1 ++ ++config BR2_GCC_TARGET_FPU ++ default "64" if BR2_LOONGARCH_FPU_64 ++ default "32" if BR2_LOONGARCH_FPU_32 ++ default "none" if BR2_LOONGARCH_FPU_NONE ++ ++config BR2_GCC_TARGET_SIMD ++ default "lasx" if BR2_LOONGARCH_SIMD_LASX ++ default "lsx" if BR2_LOONGARCH_SIMD_LSX ++ default "none" if BR2_LOONGARCH_FPU_NONE ++ ++config BR2_GCC_TARGET_ABI ++ default "lp64d" if BR2_LOONGARCH_ABI_LP64D ++ default "lp64f" if BR2_LOONGARCH_ABI_LP64F ++ default "lp64s" if BR2_LOONGARCH_ABI_LP64S ++ ++config BR2_READELF_ARCH_NAME ++ default "LoongArch" ++ ++# vim: ft=kconfig ++# -*- mode:kconfig; -*- +-- +2.43.0 + +_______________________________________________ +buildroot mailing list +buildroot@buildroot.org +https://lists.buildroot.org/mailman/listinfo/buildroot + +From git@z Thu Jan 1 00:00:00 1970 +Subject: [PATCH 4/7] package/{glibc, musl}: Enable LoongArch64 support +From: Jiaxun Yang +Date: Fri, 24 May 2024 20:36:38 +0100 +Message-Id: <20240524-loongarch64-v1-4-d24078d79cd5@flygoat.com> +MIME-Version: 1.0 +Content-Type: text/plain; charset="utf-8" +Content-Transfer-Encoding: 7bit + +Both musl and glibc have proper LoongArch support. +They all require kernel header from at least 5.19 to build. + +Signed-off-by: Jiaxun Yang +Link: https://lore.kernel.org/r/20240524-loongarch64-v1-4-d24078d79cd5@flygoat.com +--- + package/glibc/Config.in | 2 ++ + package/musl/Config.in | 1 + + toolchain/toolchain-buildroot/Config.in | 4 ++++ + 3 files changed, 7 insertions(+) + +diff --git a/package/glibc/Config.in b/package/glibc/Config.in +index 81c64083f473..484ea394a2f2 100644 +--- a/package/glibc/Config.in ++++ b/package/glibc/Config.in +@@ -5,6 +5,7 @@ config BR2_PACKAGE_GLIBC_ARCH_SUPPORTS + default y if BR2_aarch64 + default y if BR2_aarch64_be + default y if BR2_i386 ++ default y if BR2_loongarch64 + default y if BR2_m68k_m68k + default y if BR2_mips + default y if BR2_mipsel +@@ -34,6 +35,7 @@ config BR2_PACKAGE_GLIBC_SUPPORTS + # toolchain/toolchain-buildroot/Config.in + depends on BR2_TOOLCHAIN_HEADERS_AT_LEAST_3_2 + depends on BR2_TOOLCHAIN_HEADERS_AT_LEAST_3_10 || !BR2_powerpc64le ++ depends on BR2_TOOLCHAIN_HEADERS_AT_LEAST_5_19 || !BR2_loongarch64 + depends on BR2_TOOLCHAIN_HEADERS_AT_LEAST_4_5 || !BR2_MIPS_NAN_2008 + depends on BR2_TOOLCHAIN_HEADERS_AT_LEAST_5_4 || !BR2_RISCV_32 + depends on BR2_TOOLCHAIN_HEADERS_AT_LEAST_5_0 || !BR2_RISCV_64 +diff --git a/package/musl/Config.in b/package/musl/Config.in +index a6e2af054c35..70475326f5b2 100644 +--- a/package/musl/Config.in ++++ b/package/musl/Config.in +@@ -5,6 +5,7 @@ config BR2_PACKAGE_MUSL_ARCH_SUPPORTS + default y if BR2_arm + default y if BR2_armeb + default y if BR2_i386 ++ default y if BR2_loongarch64 + default y if BR2_m68k_m68k + default y if BR2_microblaze + default y if BR2_mips +diff --git a/toolchain/toolchain-buildroot/Config.in b/toolchain/toolchain-buildroot/Config.in +index 0173f40d9768..0bccdc817cc9 100644 +--- a/toolchain/toolchain-buildroot/Config.in ++++ b/toolchain/toolchain-buildroot/Config.in +@@ -48,6 +48,10 @@ comment "glibc needs a toolchain w/ kernel headers >= 3.2" + depends on BR2_PACKAGE_GLIBC_ARCH_SUPPORTS + depends on !BR2_TOOLCHAIN_HEADERS_AT_LEAST_3_2 + ++comment "glibc on LoongArch64 needs a toolchain w/ headers >= 5.19" ++ depends on BR2_loongarch64 ++ depends on !BR2_TOOLCHAIN_HEADERS_AT_LEAST_5_19 ++ + # glibc >= 2.26 require kernel headers >= 3.10 on powerpc64le. + comment "glibc on powerpc64le needs a toolchain w/ headers >= 3.10" + depends on BR2_powerpc64le +-- +2.43.0 + +_______________________________________________ +buildroot mailing list +buildroot@buildroot.org +https://lists.buildroot.org/mailman/listinfo/buildroot + +From git@z Thu Jan 1 00:00:00 1970 +Subject: [PATCH 5/7] linux: Introduce {vmlinux, vmlinuz}.efi kernel binary + format +From: Jiaxun Yang +Date: Fri, 24 May 2024 20:36:39 +0100 +Message-Id: <20240524-loongarch64-v1-5-d24078d79cd5@flygoat.com> +MIME-Version: 1.0 +Content-Type: text/plain; charset="utf-8" +Content-Transfer-Encoding: 7bit + +vmlinux.efi and vmlinuz.efi are standard file names for LoongArch +EFISTUB kernel. + +Introduce them to build system. + +Signed-off-by: Jiaxun Yang +Link: https://lore.kernel.org/r/20240524-loongarch64-v1-5-d24078d79cd5@flygoat.com +--- + linux/Config.in | 8 ++++++++ + linux/linux.mk | 4 ++++ + 2 files changed, 12 insertions(+) + +diff --git a/linux/Config.in b/linux/Config.in +index d3d4c429109c..208c0ea91929 100644 +--- a/linux/Config.in ++++ b/linux/Config.in +@@ -285,6 +285,10 @@ config BR2_LINUX_KERNEL_VMLINUX_BIN + bool "vmlinux.bin" + depends on BR2_mips || BR2_mipsel || BR2_sh + ++config BR2_LINUX_KERNEL_VMLINUX_EFI ++ bool "vmlinux.efi" ++ depends on BR2_loongarch64 ++ + config BR2_LINUX_KERNEL_VMLINUX + bool "vmlinux" + +@@ -296,6 +300,10 @@ config BR2_LINUX_KERNEL_VMLINUZ_BIN + bool "vmlinuz.bin" + depends on BR2_mips || BR2_mipsel + ++config BR2_LINUX_KERNEL_VMLINUZ_EFI ++ bool "vmlinuz.efi" ++ depends on BR2_loongarch64 ++ + config BR2_LINUX_KERNEL_IMAGE_TARGET_CUSTOM + bool "custom target" + help +diff --git a/linux/linux.mk b/linux/linux.mk +index 16d9f1947089..8c59521a9adf 100644 +--- a/linux/linux.mk ++++ b/linux/linux.mk +@@ -233,12 +233,16 @@ else ifeq ($(BR2_LINUX_KERNEL_LINUX_BIN),y) + LINUX_IMAGE_NAME = linux.bin + else ifeq ($(BR2_LINUX_KERNEL_VMLINUX_BIN),y) + LINUX_IMAGE_NAME = vmlinux.bin ++else ifeq ($(BR2_LINUX_KERNEL_VMLINUX_EFI),y) ++LINUX_IMAGE_NAME = vmlinux.efi + else ifeq ($(BR2_LINUX_KERNEL_VMLINUX),y) + LINUX_IMAGE_NAME = vmlinux + else ifeq ($(BR2_LINUX_KERNEL_VMLINUZ),y) + LINUX_IMAGE_NAME = vmlinuz + else ifeq ($(BR2_LINUX_KERNEL_VMLINUZ_BIN),y) + LINUX_IMAGE_NAME = vmlinuz.bin ++else ifeq ($(BR2_LINUX_KERNEL_VMLINUZ_EFI),y) ++LINUX_IMAGE_NAME = vmlinuz.efi + endif + # The if-else blocks above are all the image types we know of, and all + # come from a Kconfig choice, so we know we have LINUX_IMAGE_NAME set +-- +2.43.0 + +_______________________________________________ +buildroot mailing list +buildroot@buildroot.org +https://lists.buildroot.org/mailman/listinfo/buildroot + +From git@z Thu Jan 1 00:00:00 1970 +Subject: [PATCH 6/7] boot/grub2: Introduce loongarch64-efi target +From: Jiaxun Yang +Date: Fri, 24 May 2024 20:36:40 +0100 +Message-Id: <20240524-loongarch64-v1-6-d24078d79cd5@flygoat.com> +MIME-Version: 1.0 +Content-Type: text/plain; charset="utf-8" +Content-Transfer-Encoding: 7bit + +loongarch64-efi target presents in GRUB can be utilised +by any EFI compatible LoongArch64 machine to boot kernel. + +Signed-off-by: Jiaxun Yang +Link: https://lore.kernel.org/r/20240524-loongarch64-v1-6-d24078d79cd5@flygoat.com +--- + boot/grub2/Config.in | 10 ++++++++++ + boot/grub2/grub2.mk | 9 +++++++++ + 2 files changed, 19 insertions(+) + +diff --git a/boot/grub2/Config.in b/boot/grub2/Config.in +index 7c235e96f71d..8bf193d4a86c 100644 +--- a/boot/grub2/Config.in ++++ b/boot/grub2/Config.in +@@ -5,6 +5,7 @@ config BR2_TARGET_GRUB2_ARCH_SUPPORTS + default y if BR2_arm + default y if BR2_aarch64 + default y if BR2_RISCV_64 ++ default y if BR2_loongarch64 + depends on BR2_USE_MMU + + config BR2_TARGET_GRUB2 +@@ -112,6 +113,15 @@ config BR2_TARGET_GRUB2_RISCV64_EFI + 64bit RISC-V platform and you want to boot Grub 2 as an EFI + application. + ++config BR2_TARGET_GRUB2_LOONGARCH64_EFI ++ bool "loongarch64-efi" ++ depends on BR2_loongarch64 ++ select BR2_TARGET_GRUB2_HAS_EFI_BOOT ++ help ++ Select this option if the platform you're targetting is a ++ 64bit LoongArch platform and you want to boot Grub 2 as an EFI ++ application. ++ + if BR2_TARGET_GRUB2_HAS_LEGACY_BOOT + + comment "Options for the x86 legacy BIOS or ARM U-Boot support" +diff --git a/boot/grub2/grub2.mk b/boot/grub2/grub2.mk +index 6d0d71c47d08..347915431fd0 100644 +--- a/boot/grub2/grub2.mk ++++ b/boot/grub2/grub2.mk +@@ -102,6 +102,15 @@ GRUB2_BUILTIN_CONFIG_riscv64-efi = $(GRUB2_BUILTIN_CONFIG_EFI) + GRUB2_BUILTIN_MODULES_riscv64-efi = $(GRUB2_BUILTIN_MODULES_EFI) + GRUB2_TUPLES-$(BR2_TARGET_GRUB2_RISCV64_EFI) += riscv64-efi + ++GRUB2_IMAGE_loongarch64-efi = $(BINARIES_DIR)/efi-part/EFI/BOOT/bootloongarch64.efi ++GRUB2_CFG_loongarch64-efi = $(BINARIES_DIR)/efi-part/EFI/BOOT/grub.cfg ++GRUB2_PREFIX_loongarch64-efi = /EFI/BOOT ++GRUB2_TARGET_loongarch64-efi = loongarch64 ++GRUB2_PLATFORM_loongarch64-efi = efi ++GRUB2_BUILTIN_CONFIG_loongarch64-efi = $(GRUB2_BUILTIN_CONFIG_EFI) ++GRUB2_BUILTIN_MODULES_loongarch64-efi = $(GRUB2_BUILTIN_MODULES_EFI) ++GRUB2_TUPLES-$(BR2_TARGET_GRUB2_LOONGARCH64_EFI) += loongarch64-efi ++ + # Grub2 is kind of special: it considers CC, LD and so on to be the + # tools to build the host programs and uses TARGET_CC, TARGET_CFLAGS, + # TARGET_CPPFLAGS, TARGET_LDFLAGS to build the bootloader itself. +-- +2.43.0 + +_______________________________________________ +buildroot mailing list +buildroot@buildroot.org +https://lists.buildroot.org/mailman/listinfo/buildroot + +From git@z Thu Jan 1 00:00:00 1970 +Subject: [PATCH 7/7] board/loongarch64-efi: Introduce the new board +From: Jiaxun Yang +Date: Fri, 24 May 2024 20:36:41 +0100 +Message-Id: <20240524-loongarch64-v1-7-d24078d79cd5@flygoat.com> +MIME-Version: 1.0 +Content-Type: text/plain; charset="utf-8" +Content-Transfer-Encoding: 7bit + +Introduce bread new loongarch64-efi board, with skeleton +from aarch64-efi board. + +It corverd most LoongArch64 systems. + +Linux 6.6, as the most recent LTS kernel, was chosen +to ensure proper architecture support is included. + +A developer entry is created for myself for future contacts +as well. + +Signed-off-by: Jiaxun Yang +Link: https://lore.kernel.org/r/20240524-loongarch64-v1-7-d24078d79cd5@flygoat.com +--- + DEVELOPERS | 5 +++++ + board/loongarch64-efi/genimage-efi.cfg | 33 +++++++++++++++++++++++++++++++ + board/loongarch64-efi/grub.cfg | 6 ++++++ + board/loongarch64-efi/post-image.sh | 5 +++++ + board/loongarch64-efi/readme.txt | 34 ++++++++++++++++++++++++++++++++ + configs/loongarch64_efi_defconfig | 36 ++++++++++++++++++++++++++++++++++ + 6 files changed, 119 insertions(+) + +diff --git a/DEVELOPERS b/DEVELOPERS +index 52c9b84a9d41..333f952cf392 100644 +--- a/DEVELOPERS ++++ b/DEVELOPERS +@@ -1568,6 +1568,11 @@ F: package/libuhttpd/ + F: package/libuwsc/ + F: package/rtty/ + ++N: Jiaxun Yang ++F: arch/Config.in.loongarch ++F: board/loongarch64-efi ++F: configs/loongarch64_efi_defconfig ++ + N: Joachim Wiberg + F: configs/globalscale_espressobin_defconfig + F: board/globalscale/espressobin/ +diff --git a/board/loongarch64-efi/genimage-efi.cfg b/board/loongarch64-efi/genimage-efi.cfg +new file mode 100644 +index 000000000000..c78f81016d01 +--- /dev/null ++++ b/board/loongarch64-efi/genimage-efi.cfg +@@ -0,0 +1,33 @@ ++image efi-part.vfat { ++ vfat { ++ file EFI { ++ image = "efi-part/EFI" ++ } ++ file vmlinuz.efi { ++ image = "vmlinuz.efi" ++ } ++ } ++ ++ size = 64M ++} ++ ++image disk.img { ++ hdimage { ++ partition-table-type = "gpt" ++ } ++ ++ partition boot { ++ image = "efi-part.vfat" ++ partition-type-uuid = U ++ offset = 32K ++ bootable = true ++ } ++ ++ partition root { ++ # For partition-type-uuid value, see: ++ # https://uapi-group.org/specifications/specs/discoverable_partitions_specification/ ++ # SD_GPT_ROOT_LOONGARCH64 ++ partition-type-uuid = 77055800-792c-4f94-b39a-98c91b762bb6 ++ image = "rootfs.ext2" ++ } ++} +diff --git a/board/loongarch64-efi/grub.cfg b/board/loongarch64-efi/grub.cfg +new file mode 100644 +index 000000000000..42c6cb03ad19 +--- /dev/null ++++ b/board/loongarch64-efi/grub.cfg +@@ -0,0 +1,6 @@ ++set default="0" ++set timeout="5" ++ ++menuentry "Buildroot" { ++ linux /vmlinuz.efi root=PARTLABEL=root rootwait console=ttyS0,115200 ++} +diff --git a/board/loongarch64-efi/post-image.sh b/board/loongarch64-efi/post-image.sh +new file mode 100755 +index 000000000000..f0214dc8667a +--- /dev/null ++++ b/board/loongarch64-efi/post-image.sh +@@ -0,0 +1,5 @@ ++#!/bin/sh ++ ++BOARD_DIR="$(dirname $0)" ++ ++cp -f ${BOARD_DIR}/grub.cfg ${BINARIES_DIR}/efi-part/EFI/BOOT/grub.cfg +diff --git a/board/loongarch64-efi/readme.txt b/board/loongarch64-efi/readme.txt +new file mode 100644 +index 000000000000..4c4e06874c1f +--- /dev/null ++++ b/board/loongarch64-efi/readme.txt +@@ -0,0 +1,34 @@ ++The loongarch64_efi_defconfig allows to build a minimal Linux system that ++can boot on all loongarch64 systems providing an EFI firmware. ++ ++This includes almost all Loongson-3 series workstations and servers. ++ ++Building and booting ++==================== ++ ++$ make loongarch64_efi_defconfig ++$ make ++ ++The file output/images/disk.img is a complete disk image that can be ++booted, it includes the grub2 bootloader, Linux kernel and root ++filesystem. ++ ++Testing under Qemu ++================== ++ ++This image can also be tested using Qemu: ++ ++qemu-system-loongarch64 \ ++ -M virt \ ++ -cpu la464 \ ++ -nographic \ ++ -bios \ ++ -drive file=output/images/disk.img,if=none,format=raw,id=hd0 \ ++ -device virtio-blk-pci,drive=hd0 \ ++ -netdev user,id=eth0 \ ++ -device virtio-net-pci,netdev=eth0 ++ ++Note that needs to point to a valid loongarch64 UEFI ++firmware image for qemu. ++It may be provided by your distribution as a edk2-loongarch64 package, ++in path such as /usr/share/edk2/loongarch64/QEMU_EFI.fd . +diff --git a/configs/loongarch64_efi_defconfig b/configs/loongarch64_efi_defconfig +new file mode 100644 +index 000000000000..874ee58be8b8 +--- /dev/null ++++ b/configs/loongarch64_efi_defconfig +@@ -0,0 +1,36 @@ ++# Architecture ++BR2_loongarch64=y ++BR2_loongarch64_generic=y ++ ++# System ++BR2_ROOTFS_DEVICE_CREATION_DYNAMIC_EUDEV=y ++ ++## Required tools to create bootable media ++BR2_PACKAGE_HOST_GENIMAGE=y ++ ++# Bootloader ++BR2_TARGET_GRUB2=y ++BR2_TARGET_GRUB2_LOONGARCH64_EFI=y ++ ++# Filesystem / image ++BR2_TARGET_ROOTFS_EXT2=y ++BR2_TARGET_ROOTFS_EXT2_4=y ++BR2_TARGET_ROOTFS_EXT2_SIZE="200M" ++# BR2_TARGET_ROOTFS_TAR is not set ++BR2_ROOTFS_POST_IMAGE_SCRIPT="board/loongarch64-efi/post-image.sh support/scripts/genimage.sh" ++BR2_ROOTFS_POST_SCRIPT_ARGS="-c board/loongarch64-efi/genimage-efi.cfg" ++ ++# Linux headers same as kernel, a 6.6 series ++BR2_PACKAGE_HOST_LINUX_HEADERS_CUSTOM_6_6=y ++ ++# Kernel ++BR2_LINUX_KERNEL=y ++BR2_LINUX_KERNEL_CUSTOM_VERSION=y ++BR2_LINUX_KERNEL_CUSTOM_VERSION_VALUE="6.6.30" ++BR2_LINUX_KERNEL_USE_ARCH_DEFAULT_CONFIG=y ++BR2_LINUX_KERNEL_NEEDS_HOST_OPENSSL=y ++BR2_LINUX_KERNEL_VMLINUZ_EFI=y ++ ++# Host tools for genimage ++BR2_PACKAGE_HOST_DOSFSTOOLS=y ++BR2_PACKAGE_HOST_MTOOLS=y +-- +2.43.0 + +_______________________________________________ +buildroot mailing list +buildroot@buildroot.org +https://lists.buildroot.org/mailman/listinfo/buildroot + diff --git a/buildroot/arm.config b/buildroot/arm.config index 45af72c..4cca3dd 100644 --- a/buildroot/arm.config +++ b/buildroot/arm.config @@ -1,6 +1,5 @@ BR2_arm=y BR2_TOOLCHAIN_EXTERNAL=y -BR2_TOOLCHAIN_EXTERNAL_BOOTLIN=y BR2_TOOLCHAIN_EXTERNAL_BOOTLIN_ARMV5_EABI_UCLIBC_STABLE=y BR2_TARGET_GENERIC_ROOT_PASSWD="root" BR2_TARGET_GENERIC_GETTY_PORT="ttyAMA0" diff --git a/buildroot/buildroot-2023.02.2.tar.gz.sha256 b/buildroot/buildroot-2023.02.2.tar.gz.sha256 deleted file mode 100644 index 38f4451..0000000 --- a/buildroot/buildroot-2023.02.2.tar.gz.sha256 +++ /dev/null @@ -1 +0,0 @@ -44cced15a58505c93a87b215a632eba25f65560da64782fea50111f62b5ae86c buildroot-2023.02.2.tar.gz diff --git a/buildroot/buildroot-2024.02.8.tar.gz.sha256 b/buildroot/buildroot-2024.02.8.tar.gz.sha256 new file mode 100644 index 0000000..11d977e --- /dev/null +++ b/buildroot/buildroot-2024.02.8.tar.gz.sha256 @@ -0,0 +1 @@ +34c230891d73b46991e7f0313d419529e64eb1824b6677d81a83fb8e47861833 buildroot-2024.02.8.tar.gz diff --git a/buildroot/loongarch.config b/buildroot/loongarch.config index 546d0d7..f794ac3 100644 --- a/buildroot/loongarch.config +++ b/buildroot/loongarch.config @@ -1,6 +1,4 @@ BR2_loongarch64=y -BR2_BINUTILS_VERSION_2_39_X=y -BR2_GCC_VERSION_12_X=y BR2_TARGET_GENERIC_ROOT_PASSWD="root" BR2_TARGET_GENERIC_GETTY_PORT="ttyS0" BR2_ROOTFS_OVERLAY="../overlay-reboot" diff --git a/buildroot/rebuild.py b/buildroot/rebuild.py index f6229bb..075b22f 100755 --- a/buildroot/rebuild.py +++ b/buildroot/rebuild.py @@ -7,7 +7,7 @@ import shutil import subprocess -BUILDROOT_VERSION = '2023.02.2' +BUILDROOT_VERSION = '2024.02.8' SUPPORTED_ARCHES = [ 'arm64', 'arm64be', diff --git a/buildroot/v3_20221212_duanzhiwei_buildroot_add_basic_support_for_loongarch_architecture_toolchain_only.patch b/buildroot/v3_20221212_duanzhiwei_buildroot_add_basic_support_for_loongarch_architecture_toolchain_only.patch deleted file mode 100644 index 1df9b11..0000000 --- a/buildroot/v3_20221212_duanzhiwei_buildroot_add_basic_support_for_loongarch_architecture_toolchain_only.patch +++ /dev/null @@ -1,193 +0,0 @@ -From git@z Thu Jan 1 00:00:00 1970 -Subject: [PATCH v3] buildroot: Add basic support for LoongArch architecture - (toolchain only) -From: Zhiwei Duan -Date: Mon, 12 Dec 2022 16:34:57 +0800 -Message-Id: <20221212083457.8308-1-duanzhiwei@loongson.cn> -MIME-Version: 1.0 -Content-Type: text/plain; charset="utf-8" -Content-Transfer-Encoding: 7bit - -With this patch, the buildroot can compile the rootfs of the loongarch architecture. -Both external toolchain and buildroot toolchain can compile rootfs. -buildroot toolchain: binutils>=2.38 GCC>=12 Linux>=5.19 glibc>=2.36. - -Signed-off-by: Zhiwei Duan -Link: https://lore.kernel.org/r/20221212083457.8308-1-duanzhiwei@loongson.cn ---- - arch/Config.in | 16 +++++++++++ - arch/Config.in.loongarch | 52 ++++++++++++++++++++++++++++++++++++ - package/glibc/Config.in | 1 + - support/gnuconfig/config.sub | 11 ++++++-- - toolchain/Config.in | 2 +- - 5 files changed, 79 insertions(+), 3 deletions(-) - create mode 100644 arch/Config.in.loongarch - -diff --git a/arch/Config.in b/arch/Config.in -index 1c0c400a98..88f805bb1e 100644 ---- a/arch/Config.in -+++ b/arch/Config.in -@@ -251,6 +251,17 @@ config BR2_xtensa - http://en.wikipedia.org/wiki/Xtensa - http://www.tensilica.com/ - -+config BR2_loongarch64 -+ bool "LOONGARCH64 (little endian)" -+ select BR2_ARCH_IS_64 -+ select BR2_USE_MMU -+ help -+ LOONGARCH is a RISC microprocessor from LOONGARCH Technologies. Little -+ endian. -+ https://www.loongson.cn/ -+ #http://en.wikipedia.org/wiki/MIPS_Technologies -+ -+ - endchoice - - # For some architectures or specific cores, our internal toolchain -@@ -414,6 +425,11 @@ if BR2_xtensa - source "arch/Config.in.xtensa" - endif - -+if BR2_loongarch64 -+source "arch/Config.in.loongarch" -+endif -+ -+ - # Set up target binary format - choice - prompt "Target Binary Format" -diff --git a/arch/Config.in.loongarch b/arch/Config.in.loongarch -new file mode 100644 -index 0000000000..bf86490cff ---- /dev/null -+++ b/arch/Config.in.loongarch -@@ -0,0 +1,52 @@ -+# loongarch config -+config BR2_LOONGARCH_CPU_LOONGARCH64 -+ bool -+ select BR2_LOONGARCH_NAN_LEGACY -+ -+choice -+ prompt "Target Architecture Variant" -+ default BR2_loongarch_64 if BR2_loongarch64 -+ depends on BR2_loongarch64 -+ help -+ Specific CPU variant to use -+ -+config BR2_loongarch_64 -+ bool "Generic LOONGARCH64" -+ depends on BR2_ARCH_IS_64 -+ select BR2_LOONGARCH_CPU_LOONGARCH64 -+endchoice -+ -+config BR2_LOONGARCH_NAN_LEGACY -+ bool -+ -+#config BR2_GCC_TARGET_NAN -+# default "legacy" if BR2_LOONGARCH_NAN_LEGACY -+ -+config BR2_ARCH -+ default "loongarch64" if BR2_loongarch64 -+ -+config BR2_NORMALIZED_ARCH -+ default "loongarch" -+ -+config BR2_ENDIAN -+ default "LITTLE" if BR2_loongarch64 -+ -+config BR2_GCC_TARGET_ARCH -+ default "loongarch64" if BR2_loongarch_64 -+ -+config BR2_READELF_ARCH_NAME -+ default "LoongArch" -+ -+config BR2_LOONGARCH_SOFT_FLOAT -+ bool "Use soft-float" -+ #default y -+ select BR2_SOFT_FLOAT -+ help -+ If your target CPU does not have a Floating Point Unit (FPU) -+ or a kernel FPU emulator, but you still wish to support -+ floating point functions, then everything will need to be -+ compiled with soft floating point support (-msoft-float). -+ -+ -+# vim: ft=kconfig -+# -*- mode:kconfig; -*- -diff --git a/package/glibc/Config.in b/package/glibc/Config.in -index 71c50504ac..d8325610f5 100644 ---- a/package/glibc/Config.in -+++ b/package/glibc/Config.in -@@ -21,6 +21,7 @@ config BR2_PACKAGE_GLIBC_ARCH_SUPPORTS - default y if BR2_microblaze - default y if BR2_nios2 - default y if BR2_arc && BR2_ARC_ATOMIC_EXT -+ default y if BR2_loongarch64 - depends on !BR2_powerpc_SPE - depends on BR2_RISCV_ISA_RVA || !BR2_riscv - depends on BR2_USE_MMU -diff --git a/support/gnuconfig/config.sub b/support/gnuconfig/config.sub -index 9bc49a7e92..c751ddf15a 100755 ---- a/support/gnuconfig/config.sub -+++ b/support/gnuconfig/config.sub -@@ -164,7 +164,7 @@ case $1 in - basic_os=$field2 - ;; - # Manufacturers -- dec* | mips* | sequent* | encore* | pc533* | sgi* | sony* \ -+ dec* | mips* | loongarch* | sequent* | encore* | pc533* | sgi* | sony* \ - | att* | 7300* | 3300* | delta* | motorola* | sun[234]* \ - | unicom* | ibm* | next | hp | isi* | apollo | altos* \ - | convergent* | ncr* | news | 32* | 3600* | 3100* \ -@@ -632,6 +632,11 @@ case $1 in - basic_machine=ymp-cray - basic_os=unicos - ;; -+ loongarch) -+ basic_machine=loongarch-loongson -+ basic_os= -+ ;; -+ - *) - basic_machine=$1 - basic_os= -@@ -1211,6 +1216,7 @@ case $cpu-$vendor in - | mipsisa64sr71k | mipsisa64sr71kel \ - | mipsr5900 | mipsr5900el \ - | mipstx39 | mipstx39el \ -+ | loongarch | loongarch64 \ - | mmix \ - | mn10200 | mn10300 \ - | moxie \ -@@ -1253,7 +1259,8 @@ case $cpu-$vendor in - | x86 | x86_64 | xc16x | xgate | xps100 \ - | xstormy16 | xtensa* \ - | ymp \ -- | z8k | z80) -+ | z8k | z80 \ -+ | loongarch | loongarch64) - ;; - - *) -diff --git a/toolchain/Config.in b/toolchain/Config.in -index 4947ab3aae..a4939af6fb 100644 ---- a/toolchain/Config.in -+++ b/toolchain/Config.in -@@ -24,7 +24,7 @@ config BR2_TOOLCHAIN_USES_UCLIBC - # architectures - select BR2_TOOLCHAIN_HAS_UCONTEXT if BR2_ARM_CPU_HAS_ARM || BR2_i386 \ - || BR2_mips || BR2_mipsel || BR2_mips64 || BR2_mips64el \ -- || BR2_sparc || BR2_x86_64 -+ || BR2_sparc || BR2_x86_64 || BR2_loongarch64 - select BR2_TOOLCHAIN_SUPPORTS_PIE if !BR2_m68k && !BR2_microblaze && !BR2_STATIC_LIBS - - config BR2_TOOLCHAIN_USES_MUSL --- -2.20.1 - -_______________________________________________ -buildroot mailing list -buildroot@buildroot.org -https://lists.buildroot.org/mailman/listinfo/buildroot - From 5aff3321cc3fe2af51449f436e9ce0f44a835c85 Mon Sep 17 00:00:00 2001 From: Nathan Chancellor Date: Mon, 18 Nov 2024 14:42:14 -0700 Subject: [PATCH 3/4] buildroot: Add support for sparc64 Signed-off-by: Nathan Chancellor --- buildroot/rebuild.py | 1 + buildroot/sparc64.config | 7 +++++++ 2 files changed, 8 insertions(+) create mode 100644 buildroot/sparc64.config diff --git a/buildroot/rebuild.py b/buildroot/rebuild.py index 075b22f..ebe4a45 100755 --- a/buildroot/rebuild.py +++ b/buildroot/rebuild.py @@ -21,6 +21,7 @@ 'ppc64le', 'riscv', 's390', + 'sparc64', 'x86', 'x86_64', ] diff --git a/buildroot/sparc64.config b/buildroot/sparc64.config new file mode 100644 index 0000000..6526e68 --- /dev/null +++ b/buildroot/sparc64.config @@ -0,0 +1,7 @@ +BR2_sparc64=y +BR2_TOOLCHAIN_EXTERNAL=y +BR2_TARGET_GENERIC_ROOT_PASSWD="root" +BR2_TARGET_GENERIC_GETTY_PORT="ttyAMA0" +BR2_ROOTFS_OVERLAY="../overlay-poweroff" +BR2_TARGET_ROOTFS_CPIO=y +# BR2_TARGET_ROOTFS_TAR is not set From 2a2b0f7c9762af0ef69bfd8d4ff5277edb24d435 Mon Sep 17 00:00:00 2001 From: Nathan Chancellor Date: Mon, 18 Nov 2024 14:26:45 -0700 Subject: [PATCH 4/4] boot-qemu.py: Add support for sparc64 Signed-off-by: Nathan Chancellor --- boot-qemu.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/boot-qemu.py b/boot-qemu.py index 198b126..38d7bcd 100755 --- a/boot-qemu.py +++ b/boot-qemu.py @@ -31,6 +31,7 @@ 'ppc64le', 'riscv', 's390', + 'sparc64', 'x86', 'x86_64', ] @@ -656,6 +657,17 @@ def __init__(self): self._qemu_args += ['-M', 's390-ccw-virtio'] +class Sparc64QEMURunner(QEMURunner): + + def __init__(self): + super().__init__() + + self.cmdline.append('console=ttyS0') + self._default_kernel_path = Path('arch/sparc/boot/image') + self._initrd_arch = self._qemu_arch = 'sparc64' + self._qemu_args += ['-M', 'sun4u', '-cpu', 'TI UltraSparc IIi'] + + class X86QEMURunner(QEMURunner): def __init__(self): @@ -768,6 +780,7 @@ def guess_arch(kernel_arg): 'ELF 64-bit LSB executable, 64-bit PowerPC or cisco 7500, OpenPOWER ELF V2 ABI': 'ppc64le', 'ELF 64-bit LSB executable, UCB RISC-V': 'riscv', 'ELF 64-bit MSB executable, IBM S/390': 's390', + 'ELF 64-bit MSB executable, SPARC V9': 'sparc64', 'ELF 32-bit LSB executable, Intel 80386': 'x86', 'ELF 64-bit LSB executable, x86-64': 'x86_64', } # yapf: disable @@ -877,6 +890,7 @@ def parse_arguments(): 'ppc64le': PowerPC64LEQEMURunner, 'riscv': RISCVQEMURunner, 's390': S390QEMURunner, + 'sparc64': Sparc64QEMURunner, 'x86': X86QEMURunner, 'x86_64': X8664QEMURunner, }