Quelle  config.sub  Sprache: unbekannt

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

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

timestamp='2024-05-27'

# 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-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."

# 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* \
   | 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* \
     | siemens \
     | sgi* \
     | siemens \
     | sim \
     | sni \
     | sony* \
     | stratus \
     | sun \
     | sun[234]* \
     | tektronix \
     | tti* \
     | ultra \
     | unicom* \
     | wec \
     | winbond \
     | wrs)
      basic_machine=$field1-$field2
      basic_os=
      ;;
     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-*)
  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 \
   | 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|'`
  ;;
 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* \
 | 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* \
 | ironclad* \
 | 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* \
 | 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*- )
  ;;
 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*-)
  ;;
 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>&yle='color: green'>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)
# time-stamp-start: "timestamp='"
# time-stamp-format: "%:y-%02m-%02d"
# time-stamp-end: "'"
# End: