The R Project SVN R

#! /bin/sh
# Configuration validation subroutine script.
#   Copyright 1992-2025 Free Software Foundation, Inc.

# shellcheck disable=SC2006,SC2268,SC2162 # see below for rationale

timestamp='2025-07-10'

# 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
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <https://www.gnu.org/licenses/>.
#
# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
# the same distribution terms that you use for the rest of that
# program.  This Exception is an additional permission under section 7
# of the GNU General Public License, version 3 ("GPLv3").


# Please send patches to <config-patches@gnu.org>.
#
# Configuration subroutine to validate and canonicalize a configuration type.
# Supply the specified configuration type as an argument.
# If it is invalid, we print an error message on stderr and exit with code 1.
# Otherwise, we print the canonical config type on stdout and succeed.

# You can get the latest version of this script from:
# https://git.savannah.gnu.org/cgit/config.git/plain/config.sub

# This file is supposed to be the same for all GNU packages
# and recognize all the CPU types, system types and aliases
# that are meaningful with *any* GNU software.
# Each package is responsible for reporting which valid configurations
# it does not support.  The user should be able to distinguish
# a failure to support a valid configuration from a meaningless
# configuration.

# The goal of this file is to map all the various variations of a given
# machine specification into a single specification in the form:
#   CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM
# or in some cases, the newer four-part form:
#   CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM
# It is wrong to echo any other type of specification.

# 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] CPU-MFR-OPSYS or ALIAS

Canonicalize a configuration name.

Options:
  -h, --help         print this help, then exit
  -t, --time-stamp   print date of last modification, then exit
  -v, --version      print version number, then exit

Report bugs and patches to <config-patches@gnu.org>."

version="\
GNU config.sub ($timestamp)

Copyright 1992-2025 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."

# Parse command line
while test $# -gt 0 ; do
  case $1 in
    --time-stamp | --time* | -t )
       echo "$timestamp" ; exit ;;
    --version | -v )
       echo "$version" ; exit ;;
    --help | --h* | -h )
       echo "$usage"; exit ;;
    -- )     # Stop option processing
       shift; break ;;
    - ) # Use stdin as input.
       break ;;
    -* )
       echo "$me: invalid option $1$help" >&2
       exit 1 ;;

    *local*)
       # First pass through any local machine types.
       echo "$1"
       exit ;;

    * )
       break ;;
  esac
done

case $# in
 0) echo "$me: missing argument$help" >&2
    exit 1;;
 1) ;;
 *) echo "$me: too many arguments$help" >&2
    exit 1;;
esac

# Split fields of configuration type
saved_IFS=$IFS
IFS="-" read field1 field2 field3 field4 <<EOF
$1
EOF
IFS=$saved_IFS

# Separate into logical components for further validation
case $1 in
    *-*-*-*-*)
        echo "Invalid configuration '$1': more than four components" >&2
        exit 1
        ;;
    *-*-*-*)
        basic_machine=$field1-$field2
        basic_os=$field3-$field4
        ;;
    *-*-*)
        # Ambiguous whether COMPANY is present, or skipped and KERNEL-OS is two
        # parts
        maybe_os=$field2-$field3
        case $maybe_os in
              cloudabi*-eabi* \
            | kfreebsd*-gnu* \
            | knetbsd*-gnu* \
            | kopensolaris*-gnu* \
            | ironclad-* \
            | linux-* \
            | managarm-* \
            | netbsd*-eabi* \
            | netbsd*-gnu* \
            | nto-qnx* \
            | os2-emx* \
            | rtmk-nova* \
            | storm-chaos* \
            | uclinux-gnu* \
            | uclinux-uclibc* \
            | windows-* )
                basic_machine=$field1
                basic_os=$maybe_os
                ;;
            android-linux)
                basic_machine=$field1-unknown
                basic_os=linux-android
                ;;
            *)
                basic_machine=$field1-$field2
                basic_os=$field3
                ;;
        esac
        ;;
    *-*)
        case $field1-$field2 in
            # Shorthands that happen to contain a single dash
            convex-c[12] | convex-c3[248])
                basic_machine=$field2-convex
                basic_os=
                ;;
            decstation-3100)
                basic_machine=mips-dec
                basic_os=
                ;;
            *-*)
                # Second component is usually, but not always the OS
                case $field2 in
                    # Do not treat sunos as a manufacturer
                    sun*os*)
                        basic_machine=$field1
                        basic_os=$field2
                        ;;
                    # Manufacturers
                      3100* \
                    | 32* \
                    | 3300* \
                    | 3600* \
                    | 7300* \
                    | acorn \
                    | altos* \
                    | apollo \
                    | apple \
                    | atari \
                    | att* \
                    | axis \
                    | be \
                    | bull \
                    | cbm \
                    | ccur \
                    | cisco \
                    | commodore \
                    | convergent* \
                    | convex* \
                    | cray \
                    | crds \
                    | dec* \
                    | delta* \
                    | dg \
                    | digital \
                    | dolphin \
                    | encore* \
                    | gould \
                    | harris \
                    | highlevel \
                    | hitachi* \
                    | hp \
                    | ibm* \
                    | intergraph \
                    | isi* \
                    | knuth \
                    | masscomp \
                    | microblaze* \
                    | mips* \
                    | motorola* \
                    | ncr* \
                    | news \
                    | next \
                    | ns \
                    | oki \
                    | omron* \
                    | pc533* \
                    | rebel \
                    | rom68k \
                    | rombug \
                    | semi \
                    | sequent* \
                    | sgi* \
                    | siemens \
                    | sim \
                    | sni \
                    | sony* \
                    | stratus \
                    | sun \
                    | sun[234]* \
                    | tektronix \
                    | tti* \
                    | ultra \
                    | unicom* \
                    | wec \
                    | winbond \
                    | wrs)
                        basic_machine=$field1-$field2
                        basic_os=
                        ;;
                    tock* | zephyr*)
                        basic_machine=$field1-unknown
                        basic_os=$field2
                        ;;
                    *)
                        basic_machine=$field1
                        basic_os=$field2
                        ;;
                esac
            ;;
        esac
        ;;
    *)
        # Convert single-component short-hands not valid as part of
        # multi-component configurations.
        case $field1 in
            386bsd)
                basic_machine=i386-pc
                basic_os=bsd
                ;;
            a29khif)
                basic_machine=a29k-amd
                basic_os=udi
                ;;
            adobe68k)
                basic_machine=m68010-adobe
                basic_os=scout
                ;;
            alliant)
                basic_machine=fx80-alliant
                basic_os=
                ;;
            altos | altos3068)
                basic_machine=m68k-altos
                basic_os=
                ;;
            am29k)
                basic_machine=a29k-none
                basic_os=bsd
                ;;
            amdahl)
                basic_machine=580-amdahl
                basic_os=sysv
                ;;
            amiga)
                basic_machine=m68k-unknown
                basic_os=
                ;;
            amigaos | amigados)
                basic_machine=m68k-unknown
                basic_os=amigaos
                ;;
            amigaunix | amix)
                basic_machine=m68k-unknown
                basic_os=sysv4
                ;;
            apollo68)
                basic_machine=m68k-apollo
                basic_os=sysv
                ;;
            apollo68bsd)
                basic_machine=m68k-apollo
                basic_os=bsd
                ;;
            aros)
                basic_machine=i386-pc
                basic_os=aros
                ;;
            aux)
                basic_machine=m68k-apple
                basic_os=aux
                ;;
            balance)
                basic_machine=ns32k-sequent
                basic_os=dynix
                ;;
            blackfin)
                basic_machine=bfin-unknown
                basic_os=linux
                ;;
            cegcc)
                basic_machine=arm-unknown
                basic_os=cegcc
                ;;
            cray)
                basic_machine=j90-cray
                basic_os=unicos
                ;;
            crds | unos)
                basic_machine=m68k-crds
                basic_os=
                ;;
            da30)
                basic_machine=m68k-da30
                basic_os=
                ;;
            decstation | pmax | pmin | dec3100 | decstatn)
                basic_machine=mips-dec
                basic_os=
                ;;
            delta88)
                basic_machine=m88k-motorola
                basic_os=sysv3
                ;;
            dicos)
                basic_machine=i686-pc
                basic_os=dicos
                ;;
            djgpp)
                basic_machine=i586-pc
                basic_os=msdosdjgpp
                ;;
            ebmon29k)
                basic_machine=a29k-amd
                basic_os=ebmon
                ;;
            es1800 | OSE68k | ose68k | ose | OSE)
                basic_machine=m68k-ericsson
                basic_os=ose
                ;;
            gmicro)
                basic_machine=tron-gmicro
                basic_os=sysv
                ;;
            go32)
                basic_machine=i386-pc
                basic_os=go32
                ;;
            h8300hms)
                basic_machine=h8300-hitachi
                basic_os=hms
                ;;
            h8300xray)
                basic_machine=h8300-hitachi
                basic_os=xray
                ;;
            h8500hms)
                basic_machine=h8500-hitachi
                basic_os=hms
                ;;
            harris)
                basic_machine=m88k-harris
                basic_os=sysv3
                ;;
            hp300 | hp300hpux)
                basic_machine=m68k-hp
                basic_os=hpux
                ;;
            hp300bsd)
                basic_machine=m68k-hp
                basic_os=bsd
                ;;
            hppaosf)
                basic_machine=hppa1.1-hp
                basic_os=osf
                ;;
            hppro)
                basic_machine=hppa1.1-hp
                basic_os=proelf
                ;;
            i386mach)
                basic_machine=i386-mach
                basic_os=mach
                ;;
            isi68 | isi)
                basic_machine=m68k-isi
                basic_os=sysv
                ;;
            m68knommu)
                basic_machine=m68k-unknown
                basic_os=linux
                ;;
            magnum | m3230)
                basic_machine=mips-mips
                basic_os=sysv
                ;;
            merlin)
                basic_machine=ns32k-utek
                basic_os=sysv
                ;;
            mingw64)
                basic_machine=x86_64-pc
                basic_os=mingw64
                ;;
            mingw32)
                basic_machine=i686-pc
                basic_os=mingw32
                ;;
            mingw32ce)
                basic_machine=arm-unknown
                basic_os=mingw32ce
                ;;
            monitor)
                basic_machine=m68k-rom68k
                basic_os=coff
                ;;
            morphos)
                basic_machine=powerpc-unknown
                basic_os=morphos
                ;;
            moxiebox)
                basic_machine=moxie-unknown
                basic_os=moxiebox
                ;;
            msdos)
                basic_machine=i386-pc
                basic_os=msdos
                ;;
            msys)
                basic_machine=i686-pc
                basic_os=msys
                ;;
            mvs)
                basic_machine=i370-ibm
                basic_os=mvs
                ;;
            nacl)
                basic_machine=le32-unknown
                basic_os=nacl
                ;;
            ncr3000)
                basic_machine=i486-ncr
                basic_os=sysv4
                ;;
            netbsd386)
                basic_machine=i386-pc
                basic_os=netbsd
                ;;
            netwinder)
                basic_machine=armv4l-rebel
                basic_os=linux
                ;;
            news | news700 | news800 | news900)
                basic_machine=m68k-sony
                basic_os=newsos
                ;;
            news1000)
                basic_machine=m68030-sony
                basic_os=newsos
                ;;
            necv70)
                basic_machine=v70-nec
                basic_os=sysv
                ;;
            nh3000)
                basic_machine=m68k-harris
                basic_os=cxux
                ;;
            nh[45]000)
                basic_machine=m88k-harris
                basic_os=cxux
                ;;
            nindy960)
                basic_machine=i960-intel
                basic_os=nindy
                ;;
            mon960)
                basic_machine=i960-intel
                basic_os=mon960
                ;;
            nonstopux)
                basic_machine=mips-compaq
                basic_os=nonstopux
                ;;
            os400)
                basic_machine=powerpc-ibm
                basic_os=os400
                ;;
            OSE68000 | ose68000)
                basic_machine=m68000-ericsson
                basic_os=ose
                ;;
            os68k)
                basic_machine=m68k-none
                basic_os=os68k
                ;;
            paragon)
                basic_machine=i860-intel
                basic_os=osf
                ;;
            parisc)
                basic_machine=hppa-unknown
                basic_os=linux
                ;;
            psp)
                basic_machine=mipsallegrexel-sony
                basic_os=psp
                ;;
            pw32)
                basic_machine=i586-unknown
                basic_os=pw32
                ;;
            rdos | rdos64)
                basic_machine=x86_64-pc
                basic_os=rdos
                ;;
            rdos32)
                basic_machine=i386-pc
                basic_os=rdos
                ;;
            rom68k)
                basic_machine=m68k-rom68k
                basic_os=coff
                ;;
            sa29200)
                basic_machine=a29k-amd
                basic_os=udi
                ;;
            sei)
                basic_machine=mips-sei
                basic_os=seiux
                ;;
            sequent)
                basic_machine=i386-sequent
                basic_os=
                ;;
            sps7)
                basic_machine=m68k-bull
                basic_os=sysv2
                ;;
            st2000)
                basic_machine=m68k-tandem
                basic_os=
                ;;
            stratus)
                basic_machine=i860-stratus
                basic_os=sysv4
                ;;
            sun2)
                basic_machine=m68000-sun
                basic_os=
                ;;
            sun2os3)
                basic_machine=m68000-sun
                basic_os=sunos3
                ;;
            sun2os4)
                basic_machine=m68000-sun
                basic_os=sunos4
                ;;
            sun3)
                basic_machine=m68k-sun
                basic_os=
                ;;
            sun3os3)
                basic_machine=m68k-sun
                basic_os=sunos3
                ;;
            sun3os4)
                basic_machine=m68k-sun
                basic_os=sunos4
                ;;
            sun4)
                basic_machine=sparc-sun
                basic_os=
                ;;
            sun4os3)
                basic_machine=sparc-sun
                basic_os=sunos3
                ;;
            sun4os4)
                basic_machine=sparc-sun
                basic_os=sunos4
                ;;
            sun4sol2)
                basic_machine=sparc-sun
                basic_os=solaris2
                ;;
            sun386 | sun386i | roadrunner)
                basic_machine=i386-sun
                basic_os=
                ;;
            sv1)
                basic_machine=sv1-cray
                basic_os=unicos
                ;;
            symmetry)
                basic_machine=i386-sequent
                basic_os=dynix
                ;;
            t3e)
                basic_machine=alphaev5-cray
                basic_os=unicos
                ;;
            t90)
                basic_machine=t90-cray
                basic_os=unicos
                ;;
            toad1)
                basic_machine=pdp10-xkl
                basic_os=tops20
                ;;
            tpf)
                basic_machine=s390x-ibm
                basic_os=tpf
                ;;
            udi29k)
                basic_machine=a29k-amd
                basic_os=udi
                ;;
            ultra3)
                basic_machine=a29k-nyu
                basic_os=sym1
                ;;
            v810 | necv810)
                basic_machine=v810-nec
                basic_os=none
                ;;
            vaxv)
                basic_machine=vax-dec
                basic_os=sysv
                ;;
            vms)
                basic_machine=vax-dec
                basic_os=vms
                ;;
            vsta)
                basic_machine=i386-pc
                basic_os=vsta
                ;;
            vxworks960)
                basic_machine=i960-wrs
                basic_os=vxworks
                ;;
            vxworks68)
                basic_machine=m68k-wrs
                basic_os=vxworks
                ;;
            vxworks29k)
                basic_machine=a29k-wrs
                basic_os=vxworks
                ;;
            xbox)
                basic_machine=i686-pc
                basic_os=mingw32
                ;;
            ymp)
                basic_machine=ymp-cray
                basic_os=unicos
                ;;
            *)
                basic_machine=$1
                basic_os=
                ;;
        esac
        ;;
esac

# Decode 1-component or ad-hoc basic machines
case $basic_machine in
    # Here we handle the default manufacturer of certain CPU types.  It is in
    # some cases the only manufacturer, in others, it is the most popular.
    w89k)
        cpu=hppa1.1
        vendor=winbond
        ;;
    op50n)
        cpu=hppa1.1
        vendor=oki
        ;;
    op60c)
        cpu=hppa1.1
        vendor=oki
        ;;
    ibm*)
        cpu=i370
        vendor=ibm
        ;;
    orion105)
        cpu=clipper
        vendor=highlevel
        ;;
    mac | mpw | mac-mpw)
        cpu=m68k
        vendor=apple
        ;;
    pmac | pmac-mpw)
        cpu=powerpc
        vendor=apple
        ;;

    # Recognize the various machine names and aliases which stand
    # for a CPU type and a company and sometimes even an OS.
    3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc)
        cpu=m68000
        vendor=att
        ;;
    3b*)
        cpu=we32k
        vendor=att
        ;;
    bluegene*)
        cpu=powerpc
        vendor=ibm
        basic_os=cnk
        ;;
    decsystem10* | dec10*)
        cpu=pdp10
        vendor=dec
        basic_os=tops10
        ;;
    decsystem20* | dec20*)
        cpu=pdp10
        vendor=dec
        basic_os=tops20
        ;;
    delta | 3300 | delta-motorola | 3300-motorola | motorola-delta | motorola-3300)
        cpu=m68k
        vendor=motorola
        ;;
    # This used to be dpx2*, but that gets the RS6000-based
    # DPX/20 and the x86-based DPX/2-100 wrong.  See
    # https://oldskool.silicium.org/stations/bull_dpx20.htm
    # https://www.feb-patrimoine.com/english/bull_dpx2.htm
    # https://www.feb-patrimoine.com/english/unix_and_bull.htm
    dpx2 | dpx2[23]00 | dpx2[23]xx)
        cpu=m68k
        vendor=bull
        ;;
    dpx2100 | dpx21xx)
        cpu=i386
        vendor=bull
        ;;
    dpx20)
        cpu=rs6000
        vendor=bull
        ;;
    encore | umax | mmax)
        cpu=ns32k
        vendor=encore
        ;;
    elxsi)
        cpu=elxsi
        vendor=elxsi
        basic_os=${basic_os:-bsd}
        ;;
    fx2800)
        cpu=i860
        vendor=alliant
        ;;
    genix)
        cpu=ns32k
        vendor=ns
        ;;
    h3050r* | hiux*)
        cpu=hppa1.1
        vendor=hitachi
        basic_os=hiuxwe2
        ;;
    hp3k9[0-9][0-9] | hp9[0-9][0-9])
        cpu=hppa1.0
        vendor=hp
        ;;
    hp9k2[0-9][0-9] | hp9k31[0-9])
        cpu=m68000
        vendor=hp
        ;;
    hp9k3[2-9][0-9])
        cpu=m68k
        vendor=hp
        ;;
    hp9k6[0-9][0-9] | hp6[0-9][0-9])
        cpu=hppa1.0
        vendor=hp
        ;;
    hp9k7[0-79][0-9] | hp7[0-79][0-9])
        cpu=hppa1.1
        vendor=hp
        ;;
    hp9k78[0-9] | hp78[0-9])
        # FIXME: really hppa2.0-hp
        cpu=hppa1.1
        vendor=hp
        ;;
    hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893)
        # FIXME: really hppa2.0-hp
        cpu=hppa1.1
        vendor=hp
        ;;
    hp9k8[0-9][13679] | hp8[0-9][13679])
        cpu=hppa1.1
        vendor=hp
        ;;
    hp9k8[0-9][0-9] | hp8[0-9][0-9])
        cpu=hppa1.0
        vendor=hp
        ;;
    i*86v32)
        cpu=`echo "$1" | sed -e 's/86.*/86/'`
        vendor=pc
        basic_os=sysv32
        ;;
    i*86v4*)
        cpu=`echo "$1" | sed -e 's/86.*/86/'`
        vendor=pc
        basic_os=sysv4
        ;;
    i*86v)
        cpu=`echo "$1" | sed -e 's/86.*/86/'`
        vendor=pc
        basic_os=sysv
        ;;
    i*86sol2)
        cpu=`echo "$1" | sed -e 's/86.*/86/'`
        vendor=pc
        basic_os=solaris2
        ;;
    j90 | j90-cray)
        cpu=j90
        vendor=cray
        basic_os=${basic_os:-unicos}
        ;;
    iris | iris4d)
        cpu=mips
        vendor=sgi
        case $basic_os in
            irix*)
            ;;
            *)
            basic_os=irix4
            ;;
        esac
        ;;
    miniframe)
        cpu=m68000
        vendor=convergent
        ;;
    *mint | mint[0-9]* | *MiNT | *MiNT[0-9]*)
        cpu=m68k
        vendor=atari
        basic_os=mint
        ;;
    news-3600 | risc-news)
        cpu=mips
        vendor=sony
        basic_os=newsos
        ;;
    next | m*-next)
        cpu=m68k
        vendor=next
        ;;
    np1)
        cpu=np1
        vendor=gould
        ;;
    op50n-* | op60c-*)
        cpu=hppa1.1
        vendor=oki
        basic_os=proelf
        ;;
    pa-hitachi)
        cpu=hppa1.1
        vendor=hitachi
        basic_os=hiuxwe2
        ;;
    pbd)
        cpu=sparc
        vendor=tti
        ;;
    pbb)
        cpu=m68k
        vendor=tti
        ;;
    pc532)
        cpu=ns32k
        vendor=pc532
        ;;
    pn)
        cpu=pn
        vendor=gould
        ;;
    power)
        cpu=power
        vendor=ibm
        ;;
    ps2)
        cpu=i386
        vendor=ibm
        ;;
    rm[46]00)
        cpu=mips
        vendor=siemens
        ;;
    rtpc | rtpc-*)
        cpu=romp
        vendor=ibm
        ;;
    sde)
        cpu=mipsisa32
        vendor=sde
        basic_os=${basic_os:-elf}
        ;;
    simso-wrs)
        cpu=sparclite
        vendor=wrs
        basic_os=vxworks
        ;;
    tower | tower-32)
        cpu=m68k
        vendor=ncr
        ;;
    vpp*|vx|vx-*)
        cpu=f301
        vendor=fujitsu
        ;;
    w65)
        cpu=w65
        vendor=wdc
        ;;
    w89k-*)
        cpu=hppa1.1
        vendor=winbond
        basic_os=proelf
        ;;
    none)
        cpu=none
        vendor=none
        ;;
    leon|leon[3-9])
        cpu=sparc
        vendor=$basic_machine
        ;;
    leon-*|leon[3-9]-*)
        cpu=sparc
        vendor=`echo "$basic_machine" | sed 's/-.*//'`
        ;;

    *-*)
        saved_IFS=$IFS
        IFS="-" read cpu vendor <<EOF
$basic_machine
EOF
        IFS=$saved_IFS
        ;;
    # We use 'pc' rather than 'unknown'
    # because (1) that's what they normally are, and
    # (2) the word "unknown" tends to confuse beginning users.
    i*86 | x86_64)
        cpu=$basic_machine
        vendor=pc
        ;;
    # These rules are duplicated from below for sake of the special case above;
    # i.e. things that normalized to x86 arches should also default to "pc"
    pc98)
        cpu=i386
        vendor=pc
        ;;
    x64 | amd64)
        cpu=x86_64
        vendor=pc
        ;;
    # Recognize the basic CPU types without company name.
    *)
        cpu=$basic_machine
        vendor=unknown
        ;;
esac

unset -v basic_machine

# Decode basic machines in the full and proper CPU-Company form.
case $cpu-$vendor in
    # Here we handle the default manufacturer of certain CPU types in canonical form.
    # It is in some cases the only manufacturer, in others, it is the most popular.
    c[12]-convex | c[12]-unknown | c3[248]-convex | c3[248]-unknown)
        vendor=convex
        basic_os=${basic_os:-bsd}
        ;;
    craynv-unknown)
        vendor=cray
        basic_os=${basic_os:-unicosmp}
        ;;
    c90-unknown | c90-cray)
        vendor=cray
        basic_os=${basic_os:-unicos}
        ;;
    fx80-unknown)
        vendor=alliant
        ;;
    romp-unknown)
        vendor=ibm
        ;;
    mmix-unknown)
        vendor=knuth
        ;;
    microblaze-unknown | microblazeel-unknown)
        vendor=xilinx
        ;;
    rs6000-unknown)
        vendor=ibm
        ;;
    vax-unknown)
        vendor=dec
        ;;
    pdp11-unknown)
        vendor=dec
        ;;
    we32k-unknown)
        vendor=att
        ;;
    cydra-unknown)
        vendor=cydrome
        ;;
    i370-ibm*)
        vendor=ibm
        ;;
    orion-unknown)
        vendor=highlevel
        ;;
    xps-unknown | xps100-unknown)
        cpu=xps100
        vendor=honeywell
        ;;

    # Here we normalize CPU types with a missing or matching vendor
    armh-unknown | armh-alt)
        cpu=armv7l
        vendor=alt
        basic_os=${basic_os:-linux-gnueabihf}
        ;;

    # Normalized CPU+vendor pairs that imply an OS, if not otherwise specified
    m68k-isi)
        basic_os=${basic_os:-sysv}
        ;;
    m68k-sony)
        basic_os=${basic_os:-newsos}
        ;;
    m68k-tektronix)
        basic_os=${basic_os:-bsd}
        ;;
    m88k-harris)
        basic_os=${basic_os:-sysv3}
        ;;
    i386-bull | m68k-bull)
        basic_os=${basic_os:-sysv3}
        ;;
    rs6000-bull)
        basic_os=${basic_os:-bosx}
        ;;
    mips-sni)
        basic_os=${basic_os:-sysv4}
        ;;

    # Here we normalize CPU types irrespective of the vendor
    amd64-*)
        cpu=x86_64
        ;;
    blackfin-*)
        cpu=bfin
        basic_os=${basic_os:-linux}
        ;;
    c54x-*)
        cpu=tic54x
        ;;
    c55x-*)
        cpu=tic55x
        ;;
    c6x-*)
        cpu=tic6x
        ;;
    e500v[12]-*)
        cpu=powerpc
        basic_os=${basic_os}"spe"
        ;;
    mips3*-*)
        cpu=mips64
        ;;
    ms1-*)
        cpu=mt
        ;;
    m68knommu-*)
        cpu=m68k
        basic_os=${basic_os:-linux}
        ;;
    m9s12z-* | m68hcs12z-* | hcs12z-* | s12z-*)
        cpu=s12z
        ;;
    openrisc-*)
        cpu=or32
        ;;
    parisc-*)
        cpu=hppa
        basic_os=${basic_os:-linux}
        ;;
    pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*)
        cpu=i586
        ;;
    pentiumpro-* | p6-* | 6x86-* | athlon-* | athlon_*-*)
        cpu=i686
        ;;
    pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*)
        cpu=i686
        ;;
    pentium4-*)
        cpu=i786
        ;;
    ppc-* | ppcbe-*)
        cpu=powerpc
        ;;
    ppcle-* | powerpclittle-*)
        cpu=powerpcle
        ;;
    ppc64-*)
        cpu=powerpc64
        ;;
    ppc64le-* | powerpc64little-*)
        cpu=powerpc64le
        ;;
    sb1-*)
        cpu=mipsisa64sb1
        ;;
    sb1el-*)
        cpu=mipsisa64sb1el
        ;;
    sh5e[lb]-*)
        cpu=`echo "$cpu" | sed 's/^\(sh.\)e\(.\)$/\1\2e/'`
        ;;
    spur-*)
        cpu=spur
        ;;
    strongarm-* | thumb-*)
        cpu=arm
        ;;
    tx39-*)
        cpu=mipstx39
        ;;
    tx39el-*)
        cpu=mipstx39el
        ;;
    xscale-* | xscalee[bl]-*)
        cpu=`echo "$cpu" | sed 's/^xscale/arm/'`
        ;;
    arm64-* | aarch64le-* | arm64_32-*)
        cpu=aarch64
        ;;

    # Recognize the canonical CPU Types that limit and/or modify the
    # company names they are paired with.
    cr16-*)
        basic_os=${basic_os:-elf}
        ;;
    crisv32-* | etraxfs*-*)
        cpu=crisv32
        vendor=axis
        ;;
    cris-* | etrax*-*)
        cpu=cris
        vendor=axis
        ;;
    crx-*)
        basic_os=${basic_os:-elf}
        ;;
    neo-tandem)
        cpu=neo
        vendor=tandem
        ;;
    nse-tandem)
        cpu=nse
        vendor=tandem
        ;;
    nsr-tandem)
        cpu=nsr
        vendor=tandem
        ;;
    nsv-tandem)
        cpu=nsv
        vendor=tandem
        ;;
    nsx-tandem)
        cpu=nsx
        vendor=tandem
        ;;
    mipsallegrexel-sony)
        cpu=mipsallegrexel
        vendor=sony
        ;;
    tile*-*)
        basic_os=${basic_os:-linux-gnu}
        ;;

    *)
        # Recognize the canonical CPU types that are allowed with any
        # company name.
        case $cpu in
              1750a \
            | 580 \
            | [cjt]90 \
            | a29k \
            | aarch64 \
            | aarch64_be \
            | aarch64c \
            | abacus \
            | alpha \
            | alpha64 \
            | alpha64ev56 \
            | alpha64ev6[78] \
            | alpha64ev[4-8] \
            | alpha64pca5[67] \
            | alphaev56 \
            | alphaev6[78] \
            | alphaev[4-8] \
            | alphapca5[67] \
            | am33_2.0 \
            | amdgcn \
            | arc \
            | arc32 \
            | arc64 \
            | arceb \
            | arm \
            | arm64e \
            | arm64ec \
            | arm[lb]e \
            | arme[lb] \
            | armv* \
            | asmjs \
            | avr \
            | avr32 \
            | ba \
            | be32 \
            | be64 \
            | bfin \
            | bpf \
            | bs2000 \
            | c30 \
            | c4x \
            | c8051 \
            | c[123]* \
            | clipper \
            | craynv \
            | csky \
            | cydra \
            | d10v \
            | d30v \
            | dlx \
            | dsp16xx \
            | e2k \
            | elxsi \
            | epiphany \
            | f30[01] \
            | f700 \
            | fido \
            | fr30 \
            | frv \
            | ft32 \
            | fx80 \
            | h8300 \
            | h8500 \
            | hexagon \
            | hppa \
            | hppa1.[01] \
            | hppa2.0 \
            | hppa2.0[nw] \
            | hppa64 \
            | i*86 \
            | i370 \
            | i860 \
            | i960 \
            | ia16 \
            | ia64 \
            | intelgt \
            | ip2k \
            | iq2000 \
            | javascript \
            | k1om \
            | kvx \
            | le32 \
            | le64 \
            | lm32 \
            | loongarch32 \
            | loongarch64 \
            | m32c \
            | m32r \
            | m32rle \
            | m5200 \
            | m68000 \
            | m680[012346]0 \
            | m6811 \
            | m6812 \
            | m68360 \
            | m683?2 \
            | m68hc11 \
            | m68hc12 \
            | m68hcs12x \
            | m68k \
            | m88110 \
            | m88k \
            | maxq \
            | mb \
            | mcore \
            | mep \
            | metag \
            | microblaze \
            | microblazeel \
            | mips* \
            | mmix \
            | mn10200 \
            | mn10300 \
            | moxie \
            | msp430 \
            | mt \
            | nanomips* \
            | nds32 \
            | nds32be \
            | nds32le \
            | nfp \
            | nios \
            | nios2 \
            | nios2eb \
            | nios2el \
            | none \
            | np1 \
            | ns16k \
            | ns32k \
            | nvptx \
            | open8 \
            | or1k* \
            | or32 \
            | orion \
            | pdp10 \
            | pdp11 \
            | picochip \
            | pj \
            | pjl \
            | pn \
            | power \
            | powerpc \
            | powerpc64 \
            | powerpc64le \
            | powerpcle \
            | powerpcspe \
            | pru \
            | pyramid \
            | riscv \
            | riscv32 \
            | riscv32be \
            | riscv64 \
            | riscv64be \
            | rl78 \
            | romp \
            | rs6000 \
            | rx \
            | s390 \
            | s390x \
            | score \
            | sh \
            | sh64 \
            | sh64le \
            | sh[12345][lb]e \
            | sh[1234] \
            | sh[1234]e[lb] \
            | sh[23]e \
            | sh[23]ele \
            | sh[24]a \
            | sh[24]ae[lb] \
            | sh[lb]e \
            | she[lb] \
            | shl \
            | sparc \
            | sparc64 \
            | sparc64b \
            | sparc64v \
            | sparc86x \
            | sparclet \
            | sparclite \
            | sparcv8 \
            | sparcv9 \
            | sparcv9b \
            | sparcv9v \
            | spu \
            | sv1 \
            | sx* \
            | tahoe \
            | thumbv7* \
            | tic30 \
            | tic4x \
            | tic54x \
            | tic55x \
            | tic6x \
            | tic80 \
            | tron \
            | ubicom32 \
            | v70 \
            | v810 \
            | v850 \
            | v850e \
            | v850e1 \
            | v850e2 \
            | v850e2v3 \
            | v850es \
            | vax \
            | vc4 \
            | visium \
            | w65 \
            | wasm32 \
            | wasm64 \
            | we32k \
            | x86 \
            | x86_64 \
            | xc16x \
            | xgate \
            | xps100 \
            | xstormy16 \
            | xtensa* \
            | ymp \
            | z80 \
            | z8k)
                ;;

            *)
                echo "Invalid configuration '$1': machine '$cpu-$vendor' not recognized" 1>&2
                exit 1
                ;;
        esac
        ;;
esac

# Here we canonicalize certain aliases for manufacturers.
case $vendor in
    digital*)
        vendor=dec
        ;;
    commodore*)
        vendor=cbm
        ;;
    *)
        ;;
esac

# Decode manufacturer-specific aliases for certain operating systems.

if test x"$basic_os" != x
then

# 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|'`
        ;;
    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|'`
        ;;
    *-*)
        saved_IFS=$IFS
        IFS="-" read kernel os <<EOF
$basic_os
EOF
        IFS=$saved_IFS
        ;;
    # Default OS when just kernel was specified
    nto*)
        kernel=nto
        os=`echo "$basic_os" | sed -e 's|nto|qnx|'`
        ;;
    ironclad*)
        kernel=ironclad
        os=`echo "$basic_os" | sed -e 's|ironclad|mlibc|'`
        ;;
    linux*)
        kernel=linux
        os=`echo "$basic_os" | sed -e 's|linux|gnu|'`
        ;;
    managarm*)
        kernel=managarm
        os=`echo "$basic_os" | sed -e 's|managarm|mlibc|'`
        ;;
    *)
        kernel=
        os=$basic_os
        ;;
esac

# Now, normalize the OS (knowing we just have one component, it's not a kernel,
# etc.)
case $os in
    # First match some system type aliases that might get confused
    # with valid system types.
    # solaris* is a basic system type, with this one exception.
    auroraux)
        os=auroraux
        ;;
    bluegene*)
        os=cnk
        ;;
    solaris1 | solaris1.*)
        os=`echo "$os" | sed -e 's|solaris1|sunos4|'`
        ;;
    solaris)
        os=solaris2
        ;;
    unixware*)
        os=sysv4.2uw
        ;;
    # The marketing names for NeXT's operating systems were
    # NeXTSTEP, NeXTSTEP 2, OpenSTEP 3, OpenSTEP 4.  'openstep' is
    # mapped to 'openstep3', but 'openstep1' and 'openstep2' are
    # mapped to 'nextstep' and 'nextstep2', consistent with the
    # treatment of SunOS/Solaris.
    ns | ns1 | nextstep | nextstep1 | openstep1)
        os=nextstep
        ;;
    ns2 | nextstep2 | openstep2)
        os=nextstep2
        ;;
    ns3 | nextstep3 | openstep | openstep3)
        os=openstep3
        ;;
    ns4 | nextstep4 | openstep4)
        os=openstep4
        ;;
    # es1800 is here to avoid being matched by es* (a different OS)
    es1800*)
        os=ose
        ;;
    # Some version numbers need modification
    chorusos*)
        os=chorusos
        ;;
    isc)
        os=isc2.2
        ;;
    sco6)
        os=sco5v6
        ;;
    sco5)
        os=sco3.2v5
        ;;
    sco4)
        os=sco3.2v4
        ;;
    sco3.2.[4-9]*)
        os=`echo "$os" | sed -e 's/sco3.2./sco3.2v/'`
        ;;
    sco*v* | scout)
        # Don't match below
        ;;
    sco*)
        os=sco3.2v2
        ;;
    psos*)
        os=psos
        ;;
    qnx*)
        os=qnx
        ;;
    hiux*)
        os=hiuxwe2
        ;;
    lynx*178)
        os=lynxos178
        ;;
    lynx*5)
        os=lynxos5
        ;;
    lynxos*)
        # don't get caught up in next wildcard
        ;;
    lynx*)
        os=lynxos
        ;;
    mac[0-9]*)
        os=`echo "$os" | sed -e 's|mac|macos|'`
        ;;
    opened*)
        os=openedition
        ;;
    os400*)
        os=os400
        ;;
    sunos5*)
        os=`echo "$os" | sed -e 's|sunos5|solaris2|'`
        ;;
    sunos6*)
        os=`echo "$os" | sed -e 's|sunos6|solaris3|'`
        ;;
    wince*)
        os=wince
        ;;
    utek*)
        os=bsd
        vendor=`echo "$vendor" | sed -e 's|^unknown$|tektronix|'`
        ;;
    dynix*)
        os=bsd
        ;;
    acis*)
        os=aos
        ;;
    atheos*)
        os=atheos
        ;;
    syllable*)
        os=syllable
        ;;
    386bsd)
        os=bsd
        ;;
    ctix*)
        os=sysv
        vendor=`echo "$vendor" | sed -e 's|^unknown$|convergent|'`
        ;;
    uts*)
        os=sysv
        ;;
    nova*)
        kernel=rtmk
        os=nova
        ;;
    # Preserve the version number of sinix5.
    sinix5.*)
        os=`echo "$os" | sed -e 's|sinix|sysv|'`
        vendor=`echo "$vendor" | sed -e 's|^unknown$|sni|'`
        ;;
    sinix*)
        os=sysv4
        vendor=`echo "$vendor" | sed -e 's|^unknown$|sni|'`
        ;;
    tpf*)
        os=tpf
        ;;
    triton*)
        os=sysv3
        ;;
    oss*)
        os=sysv3
        ;;
    svr4*)
        os=sysv4
        ;;
    svr3)
        os=sysv3
        ;;
    sysvr4)
        os=sysv4
        ;;
    ose*)
        os=ose
        ;;
    *mint | mint[0-9]* | *MiNT | MiNT[0-9]*)
        os=mint
        ;;
    dicos*)
        os=dicos
        ;;
    pikeos*)
        # Until real need of OS specific support for
        # particular features comes up, bare metal
        # configurations are quite functional.
        case $cpu in
            arm*)
            os=eabi
            ;;
            *)
            os=
            obj=elf
            ;;
        esac
        ;;
    aout* | coff* | elf* | pe*)
        # These are machine code file formats, not OSes
        obj=$os
        os=
        ;;
    *)
        # No normalization, but not necessarily accepted, that comes below.
        ;;
esac

else

# Here we handle the default operating systems that come with various machines.
# The value should be what the vendor currently ships out the door with their
# machine or put another way, the most popular os provided with the machine.

# Note that if you're going to try to match "-MANUFACTURER" here (say,
# "-sun"), then you have to tell the case statement up towards the top
# that MANUFACTURER isn't an operating system.  Otherwise, code above
# will signal an error saying that MANUFACTURER isn't an operating
# system, and we'll never get to this point.

kernel=
obj=
case $cpu-$vendor in
    score-*)
        os=
        obj=elf
        ;;
    spu-*)
        os=
        obj=elf
        ;;
    *-acorn)
        os=riscix1.2
        ;;
    arm*-rebel)
        kernel=linux
        os=gnu
        ;;
    arm*-semi)
        os=
        obj=aout
        ;;
    c4x-* | tic4x-*)
        os=
        obj=coff
        ;;
    c8051-*)
        os=
        obj=elf
        ;;
    clipper-intergraph)
        os=clix
        ;;
    hexagon-*)
        os=
        obj=elf
        ;;
    tic54x-*)
        os=
        obj=coff
        ;;
    tic55x-*)
        os=
        obj=coff
        ;;
    tic6x-*)
        os=
        obj=coff
        ;;
    # This must come before the *-dec entry.
    pdp10-*)
        os=tops20
        ;;
    pdp11-*)
        os=none
        ;;
    *-dec | vax-*)
        os=ultrix4.2
        ;;
    m68*-apollo)
        os=domain
        ;;
    i386-sun)
        os=sunos4.0.2
        ;;
    m68000-sun)
        os=sunos3
        ;;
    m68*-cisco)
        os=
        obj=aout
        ;;
    mep-*)
        os=
        obj=elf
        ;;
    # The -sgi and -siemens entries must be before the mips- entry
    # or we get the wrong os.
    *-sgi)
        os=irix
        ;;
    *-siemens)
        os=sysv4
        ;;
    mips*-cisco)
        os=
        obj=elf
        ;;
    mips*-*|nanomips*-*)
        os=
        obj=elf
        ;;
    or32-*)
        os=
        obj=coff
        ;;
    # This must be before the sparc-* entry or we get the wrong os.
    *-tti)
        os=sysv3
        ;;
    sparc-* | *-sun)
        os=sunos4.1.1
        ;;
    pru-*)
        os=
        obj=elf
        ;;
    *-be)
        os=beos
        ;;
    *-ibm)
        os=aix
        ;;
    *-knuth)
        os=mmixware
        ;;
    *-wec)
        os=proelf
        ;;
    *-winbond)
        os=proelf
        ;;
    *-oki)
        os=proelf
        ;;
    *-hp)
        os=hpux
        ;;
    *-hitachi)
        os=hiuxwe2
        ;;
    i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent)
        os=sysv
        ;;
    *-cbm)
        os=amigaos
        ;;
    *-dg)
        os=dgux
        ;;
    *-dolphin)
        os=sysv3
        ;;
    m68k-ccur)
        os=rtu
        ;;
    m88k-omron*)
        os=luna
        ;;
    *-next)
        os=nextstep
        ;;
    *-sequent)
        os=ptx
        ;;
    *-crds)
        os=unos
        ;;
    *-ns)
        os=genix
        ;;
    i370-*)
        os=mvs
        ;;
    *-gould)
        os=sysv
        ;;
    *-highlevel)
        os=bsd
        ;;
    *-encore)
        os=bsd
        ;;
    *-masscomp)
        os=rtu
        ;;
    f30[01]-fujitsu | f700-fujitsu)
        os=uxpv
        ;;
    *-rom68k)
        os=
        obj=coff
        ;;
    *-*bug)
        os=
        obj=coff
        ;;
    *-apple)
        os=macos
        ;;
    *-atari*)
        os=mint
        ;;
    *-wrs)
        os=vxworks
        ;;
    *)
        os=none
        ;;
esac

fi

# Now, validate our (potentially fixed-up) individual pieces (OS, OBJ).

case $os in
    # Sometimes we do "kernel-libc", so those need to count as OSes.
    llvm* | musl* | newlib* | relibc* | uclibc*)
        ;;
    # Likewise for "kernel-abi"
    eabi* | gnueabi*)
        ;;
    # VxWorks passes extra cpu info in the 4th filed.
    simlinux | simwindows | spe)
        ;;
    # See `case $cpu-$os` validation below
    ghcjs)
        ;;
    # Now accept the basic system types.
    # Each alternative MUST end in a * to match a version number.
      abug \
    | aix* \
    | amdhsa* \
    | amigados* \
    | amigaos* \
    | android* \
    | aof* \
    | aos* \
    | aros* \
    | atheos* \
    | auroraux* \
    | aux* \
    | banan_os* \
    | beos* \
    | bitrig* \
    | bme* \
    | bosx* \
    | bsd* \
    | cegcc* \
    | chorusos* \
    | chorusrdb* \
    | clix* \
    | cloudabi* \
    | cnk* \
    | conix* \
    | cos* \
    | cxux* \
    | cygwin* \
    | darwin* \
    | dgux* \
    | dicos* \
    | dnix* \
    | domain* \
    | dragonfly* \
    | drops* \
    | ebmon* \
    | ecoff* \
    | ekkobsd* \
    | emscripten* \
    | emx* \
    | es* \
    | fiwix* \
    | freebsd* \
    | fuchsia* \
    | genix* \
    | genode* \
    | glidix* \
    | gnu* \
    | go32* \
    | haiku* \
    | hcos* \
    | hiux* \
    | hms* \
    | hpux* \
    | ieee* \
    | interix* \
    | ios* \
    | iris* \
    | irix* \
    | isc* \
    | its* \
    | l4re* \
    | libertybsd* \
    | lites* \
    | lnews* \
    | luna* \
    | lynxos* \
    | mach* \
    | macos* \
    | magic* \
    | mbr* \
    | midipix* \
    | midnightbsd* \
    | mingw32* \
    | mingw64* \
    | minix* \
    | mint* \
    | mirbsd* \
    | mks* \
    | mlibc* \
    | mmixware* \
    | mon960* \
    | morphos* \
    | moss* \
    | moxiebox* \
    | mpeix* \
    | mpw* \
    | msdos* \
    | msys* \
    | mvs* \
    | nacl* \
    | netbsd* \
    | netware* \
    | newsos* \
    | nextstep* \
    | nindy* \
    | nonstopux* \
    | nova* \
    | nsk* \
    | nucleus* \
    | nx6 \
    | nx7 \
    | oabi* \
    | ohos* \
    | onefs* \
    | openbsd* \
    | openedition* \
    | openstep* \
    | os108* \
    | os2* \
    | os400* \
    | os68k* \
    | os9* \
    | ose* \
    | osf* \
    | oskit* \
    | osx* \
    | palmos* \
    | phoenix* \
    | plan9* \
    | powermax* \
    | powerunix* \
    | proelf* \
    | psos* \
    | psp* \
    | ptx* \
    | pw32* \
    | qnx* \
    | rdos* \
    | redox* \
    | rhapsody* \
    | riscix* \
    | riscos* \
    | rtems* \
    | rtmk* \
    | rtu* \
    | scout* \
    | secbsd* \
    | sei* \
    | serenity* \
    | sim* \
    | skyos* \
    | solaris* \
    | solidbsd* \
    | sortix* \
    | storm-chaos* \
    | sunos \
    | sunos[34]* \
    | superux* \
    | syllable* \
    | sym* \
    | sysv* \
    | tenex* \
    | tirtos* \
    | tock* \
    | toppers* \
    | tops10* \
    | tops20* \
    | tpf* \
    | tvos* \
    | twizzler* \
    | uclinux* \
    | udi* \
    | udk* \
    | ultrix* \
    | unicos* \
    | uniplus* \
    | unleashed* \
    | unos* \
    | uwin* \
    | uxpv* \
    | v88r* \
    |*vms* \
    | vos* \
    | vsta* \
    | vxsim* \
    | vxworks* \
    | wasi* \
    | watchos* \
    | wince* \
    | windiss* \
    | windows* \
    | winnt* \
    | xenix* \
    | xray* \
    | zephyr* \
    | zvmoe* )
        ;;
    # This one is extra strict with allowed versions
    sco3.2v2 | sco3.2v[4-9]* | sco5v6*)
        # Don't forget version if it is 3.2v4 or newer.
        ;;
    # This refers to builds using the UEFI calling convention
    # (which depends on the architecture) and PE file format.
    # Note that this is both a different calling convention and
    # different file format than that of GNU-EFI
    # (x86_64-w64-mingw32).
    uefi)
        ;;
    none)
        ;;
    kernel* | msvc* )
        # Restricted further below
        ;;
    '')
        if test x"$obj" = x
        then
            echo "Invalid configuration '$1': Blank OS only allowed with explicit machine code file format" 1>&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': 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-$obj in
    linux-gnu*- | linux-android*- | linux-dietlibc*- | linux-llvm*- \
            | linux-mlibc*- | linux-musl*- | linux-newlib*- \
            | linux-relibc*- | linux-uclibc*- | linux-ohos*- )
        ;;
    uclinux-uclibc*- | uclinux-gnu*- )
        ;;
    ironclad-mlibc*-)
        ;;
    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
        exit 1
        ;;
    -kernel*- )
        echo "Invalid configuration '$1': '$os' needs explicit kernel." 1>&2
        exit 1
        ;;
    *-kernel*- )
        echo "Invalid configuration '$1': '$kernel' does not support '$os'." 1>&2
        exit 1
        ;;
    *-msvc*- )
        echo "Invalid configuration '$1': '$os' needs 'windows'." 1>&2
        exit 1
        ;;
    kfreebsd*-gnu*- | knetbsd*-gnu*- | netbsd*-gnu*- | kopensolaris*-gnu*-)
        ;;
    vxworks-simlinux- | vxworks-simwindows- | vxworks-spe-)
        ;;
    nto-qnx*-)
        ;;
    os2-emx-)
        ;;
    rtmk-nova-)
        ;;
    *-eabi*- | *-gnueabi*-)
        ;;
    ios*-simulator- | tvos*-simulator- | watchos*-simulator- )
        ;;
    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.
        ;;
    --*)
        # 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

# Here we handle the case where we know the os, and the CPU type, but not the
# manufacturer.  We pick the logical manufacturer.
case $vendor in
    unknown)
        case $cpu-$os in
            *-riscix*)
                vendor=acorn
                ;;
            *-sunos* | *-solaris*)
                vendor=sun
                ;;
            *-cnk* | *-aix*)
                vendor=ibm
                ;;
            *-beos*)
                vendor=be
                ;;
            *-hpux*)
                vendor=hp
                ;;
            *-mpeix*)
                vendor=hp
                ;;
            *-hiux*)
                vendor=hitachi
                ;;
            *-unos*)
                vendor=crds
                ;;
            *-dgux*)
                vendor=dg
                ;;
            *-luna*)
                vendor=omron
                ;;
            *-genix*)
                vendor=ns
                ;;
            *-clix*)
                vendor=intergraph
                ;;
            *-mvs* | *-opened*)
                vendor=ibm
                ;;
            *-os400*)
                vendor=ibm
                ;;
            s390-* | s390x-*)
                vendor=ibm
                ;;
            *-ptx*)
                vendor=sequent
                ;;
            *-tpf*)
                vendor=ibm
                ;;
            *-vxsim* | *-vxworks* | *-windiss*)
                vendor=wrs
                ;;
            *-aux*)
                vendor=apple
                ;;
            *-hms*)
                vendor=hitachi
                ;;
            *-mpw* | *-macos*)
                vendor=apple
                ;;
            *-*mint | *-mint[0-9]* | *-*MiNT | *-MiNT[0-9]*)
                vendor=atari
                ;;
            *-vos*)
                vendor=stratus
                ;;
        esac
        ;;
esac

echo "$cpu-$vendor${kernel:+-$kernel}${os:+-$os}${obj:+-$obj}"
exit

# Local variables:
# eval: (add-hook 'before-save-hook 'time-stamp nil t)
# time-stamp-start: "timestamp='"
# time-stamp-format: "%Y-%02m-%02d"
# time-stamp-end: "'"
# End: