gcc/genmultilib - gcc - Git at Google

 #!/bin/sh
 # Generates multilib.h.
 #   Copyright (C) 1994-2019 Free Software Foundation, Inc.

 #This file is part of GCC.

 #GCC 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, or (at your option) any later
 #version.

 #GCC 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 GCC; see the file COPYING3.  If not see
 #<http://www.gnu.org/licenses/>.

 # This shell script produces a header file which the gcc driver
 # program uses to pick which library to use based on the machine
 # specific options that it is given.

 # The first argument is a list of sets of options.  The elements in
 # the list are separated by spaces.  Within an element, the options
 # are separated by slashes or pipes.  No leading dash is used on the
 # options.
 # Each option in a set separated by slashes is mutually incompatible
 # with all other options
 # in the set.
 # Each option in a set separated by pipes will be used for the library
 # compilation and any of the options in the set will be sufficient
 # for it to be triggered.

 # The optional second argument is a list of subdirectory names.  If
 # the second argument is non-empty, there must be as many elements in
 # the second argument as there are options in the first argument.  The
 # elements in the second list are separated by spaces.  If the second
 # argument is empty, the option names will be used as the directory
 # names.

 # The optional third argument is a list of options which are
 # identical.  The elements in the list are separated by spaces.  Each
 # element must be of the form OPTION=OPTION.  The first OPTION should
 # appear in the first argument, and the second should be a synonym for
 # it.  Question marks are replaced with equal signs in both options.

 # The optional fourth argument is a list of multilib directory
 # combinations that should not be built.

 # The optional fifth argument is a list of options that should be
 # used whenever building multilib libraries.

 # The optional sixth argument is a list of exclusions used internally by
 # the compiler similar to exceptions. The difference being that exclusions
 # allow matching default options that genmultilib does not know about and
 # is done at runtime as opposed to being sorted out at compile time.
 # Each element in the list is a separate exclusion rule. Each rule is
 # a list of options (sans preceding '-') separated by a '/'. The options
 # on the rule are grouped as an AND operation, and all options much match
 # for the rule to exclude a set. Options can be preceded with a '!' to
 # match a logical NOT.

 # The optional seventh argument is a list of OS subdirectory names.
 # The format is either the same as of the second argument, or a set of
 # mappings. When it is the same as the second argument, it describes
 # the multilib directories using OS conventions, rather than GCC
 # conventions.  When it is a set of mappings of the form gccdir=osdir,
 # the left side gives the GCC convention and the right gives the
 # equivalent OS defined location.  If the osdir part begins with a !,
 # the os directory names are used exclusively.  Use the mapping when
 # there is no one-to-one equivalence between GCC levels and the OS.

 # The optional eighth argument which intends to reduce the effort to write
 # so many MULTILIB_EXCEPTIONS rules. This option defines a series of option
 # combinations that we actually required.
 # For some cases, the generated option combinations are far more than what
 # we need, we have to write a lot of rules to screen out combinations we
 # don't need. If we missed some rules, the unexpected libraries will be built.
 # Now with this argument, one can simply give what combinations are needed.
 # It is pretty straigtforward.
 # This argument can be used together with MULTILIB_EXCEPTIONS and will take
 # effect after the MULTILIB_EXCEPTIONS.

 # The optional ninth argument is the multiarch name.

 # The optional tenth argument specifies how to reuse multilib for different
 # option sets.

 # The last option should be "yes" if multilibs are enabled.  If it is not
 # "yes", all GCC multilib dir names will be ".".

 # The output looks like
 #   #define MULTILIB_MATCHES "\
 #   SUBDIRECTORY OPTIONS;\
 #   ...
 #   "
 # The SUBDIRECTORY is the subdirectory to use.  The OPTIONS are
 # multiple options separated by spaces.  Each option may start with an
 # exclamation point.  gcc will consider each line in turn.  If none of
 # the options beginning with an exclamation point are present, and all
 # of the other options are present, that subdirectory will be used.
 # The order of the subdirectories is such that they can be created in
 # order; that is, a subdirectory is preceded by all its parents.

 # Here is an example (this is from the actual sparc64 case):
 #   genmultilib 'm64/m32 mno-app-regs|mcmodel=medany' '64 32 alt'
 #		'mcmodel?medany=mcmodel?medmid' 'm32/mno-app-regs* m32/mcmodel=*'
 #		'' 'm32/!m64/mno-app-regs m32/!m64/mcmodel=medany'
 #		'../lib64 ../lib32 alt' '' '' '' yes
 # This produces:
 #   ". !m64 !m32 !mno-app-regs !mcmodel=medany;",
 #   "64:../lib64 m64 !m32 !mno-app-regs !mcmodel=medany;",
 #   "32:../lib32 !m64 m32 !mno-app-regs !mcmodel=medany;",
 #   "alt !m64 !m32 mno-app-regs mcmodel=medany;",
 #   "alt !m64 !m32 mno-app-regs !mcmodel=medany;",
 #   "alt !m64 !m32 !mno-app-regs mcmodel=medany;",
 #   "64/alt:../lib64/alt m64 !m32 mno-app-regs mcmodel=medany;",
 #   "64/alt:../lib64/alt m64 !m32 mno-app-regs !mcmodel=medany;",
 #   "64/alt:../lib64/alt m64 !m32 !mno-app-regs mcmodel=medany;",
 #
 # The effect is that `gcc -mno-app-regs' (for example) will append "alt"
 # to the directory name when searching for libraries or startup files and
 # `gcc -m32 -mcmodel=medany' (for example) will append "32/alt". Also note
 # that exclusion above is moot, unless the compiler had a default of -m32,
 # which would mean that all of the "alt" directories (not the 64/alt ones)
 # would be ignored (not generated, nor used) since the exclusion also
 # matches the multilib_default args.

 # Copy the positional parameters into variables.
 options=$1
 dirnames=$2
 matches=$3
 exceptions=$4
 extra=$5
 exclusions=$6
 osdirnames=$7
 multilib_required=$8
 multiarch=$9
 multilib_reuse=${10}
 enable_multilib=${11}

 echo "static const char *const multilib_raw[] = {"

 mkdir tmpmultilib.$$ || exit 1
 # Use cd ./foo to avoid CDPATH output.
 cd ./tmpmultilib.$$ || exit 1

 # What we want to do is select all combinations of the sets in
 # options.  Each combination which includes a set of mutually
 # exclusive options must then be output multiple times, once for each
 # item in the set.  Selecting combinations is a recursive process.
 # Since not all versions of sh support functions, we achieve recursion
 # by creating a temporary shell script which invokes itself.
 rm -f tmpmultilib
 cat >tmpmultilib <<\EOF
 #!/bin/sh
 # This recursive script basically outputs all combinations of its
 # input arguments, handling mutually exclusive sets of options by
 # repetition.  When the script is called, ${initial} is the list of
 # options which should appear before all combinations this will
 # output.  The output looks like a list of subdirectory names with
 # leading and trailing slashes.
 if [ "$#" != "0" ]; then
   first=$1
   shift
   case "$first" in
   *\|*)
     all=${initial}`echo $first | sed -e 's_|_/_'g`
     first=`echo $first | sed -e 's_|_ _'g`
     echo ${all}/
     initial="${initial}${all}/" ./tmpmultilib $@
     ./tmpmultilib $first $@ | grep -v "^${all}"
     ;;
   *)
     for opt in `echo $first | sed -e 's|/| |'g`; do
       echo ${initial}${opt}/
     done
     ./tmpmultilib $@
     for opt in `echo $first | sed -e 's|/| |'g`; do
       initial="${initial}${opt}/" ./tmpmultilib $@
     done
   esac
 fi
 EOF
 chmod +x tmpmultilib

 combinations=`initial=/ ./tmpmultilib ${options}`

 # If there exceptions, weed them out now
 if [ -n "${exceptions}" ]; then
   cat >tmpmultilib2 <<\EOF
 #!/bin/sh
 # This recursive script weeds out any combination of multilib
 # switches that should not be generated.  The output looks like
 # a list of subdirectory names with leading and trailing slashes.

   for opt in $@; do
     case "$opt" in
 EOF

   for except in ${exceptions}; do
     echo "      /${except}/) : ;;" >> tmpmultilib2
   done

 cat >>tmpmultilib2 <<\EOF
       *) echo ${opt};;
     esac
   done
 EOF
   chmod +x tmpmultilib2
   combinations=`./tmpmultilib2 ${combinations}`
 fi

 # If the MULTILIB_REQUIRED list are provided,
 # filter out combinations not in this list.
 if [ -n "${multilib_required}" ]; then
   cat >tmpmultilib2 <<\EOF
 #!/bin/sh
 # This recursive script weeds out any combination of multilib
 # switches that not in the expected list.

   for opt in $@; do
     case "$opt" in
 EOF

   for expect in ${multilib_required}; do
     echo "      /${expect}/) echo \${opt};;" >> tmpmultilib2
   done

 cat >>tmpmultilib2 <<\EOF
       *) ;;
     esac
   done
 EOF

    chmod +x tmpmultilib2
    combinations=`./tmpmultilib2 ${combinations}`

 fi

 # Construct a sed pattern which will convert option names to directory
 # names.
 todirnames=
 if [ -n "${dirnames}" ]; then
   set x ${dirnames}
   shift
   for set in ${options}; do
     for opts in `echo ${set} | sed -e 's|/| |'g`; do
       patt="/"
       for opt in `echo ${opts} | sed -e 's_|_ _'g`; do
         if [ "$1" != "${opt}" ]; then
           todirnames="${todirnames} -e s|/${opt}/|/${1}/|g"
 	  patt="${patt}${1}/"
 	  if [ "${patt}" != "/${1}/" ]; then
 	    todirnames="${todirnames} -e s|${patt}|/${1}/|g"
           fi
         fi
       done
       shift
     done
   done
 fi

 # Construct a sed pattern which will convert option names to OS directory
 # names.
 toosdirnames=
 defaultosdirname=
 defaultosdirname2=
 if [ -n "${multiarch}" ]; then
   defaultosdirname=::${multiarch}
 fi
 if [ -n "${osdirnames}" ]; then
   set x ${osdirnames}
   shift
   while [ $# != 0 ] ; do
     case "$1" in
       .=*)
         defaultosdirname=`echo $1 | sed 's|^.=|:|'`
 	if [ -n "${multiarch}" ]; then
 	  defaultosdirname=${defaultosdirname}:${multiarch}
 	fi
 	case "$defaultosdirname" in
 	  ::*) ;;
 	  *)
 	    defaultosdirname2=${defaultosdirname}
 	    defaultosdirname=
 	    ;;
 	esac
 	shift
 	;;
       *=*)
 	patt=`echo $1 | sed -e 's|=|/$=/|'`
         toosdirnames="${toosdirnames} -e s=^/${patt}/="
 	shift
         ;;
       *)
         break
 	;;
     esac
   done

   if [ $# != 0 ]; then
     for set in ${options}; do
       for opts in `echo ${set} | sed -e 's|/| |'g`; do
         patt="/"
         for opt in `echo ${opts} | sed -e 's_|_ _'g`; do
           if [ "$1" != "${opt}" ]; then
             toosdirnames="${toosdirnames} -e s|/${opt}/|/${1}/|g"
 	    patt="${patt}${1}/"
 	    if [ "${patt}" != "/${1}/" ]; then
 	      toosdirnames="${toosdirnames} -e s|${patt}|/${1}/|g"
             fi
           fi
         done
         shift
       done
     done
   fi
 fi

 # We need another recursive shell script to correctly handle positive
 # matches.  If we are invoked as
 #   genmultilib "opt1 opt2" "" "opt1=nopt1 opt2=nopt2"
 # we must output
 #   opt1/opt2 opt1 opt2
 #   opt1/opt2 nopt1 opt2
 #   opt1/opt2 opt1 nopt2
 #   opt1/opt2 nopt1 nopt2
 # In other words, we must output all combinations of matches.
 rm -f tmpmultilib2
 cat >tmpmultilib2 <<\EOF
 #!/bin/sh
 # The positional parameters are a list of matches to consider.
 # ${dirout} is the directory name and ${optout} is the current list of
 # options.
 if [ "$#" = "0" ]; then
   echo "\"${dirout} ${optout};\","
 else
   first=$1
   shift
   dirout="${dirout}" optout="${optout}" ./tmpmultilib2 $@
   l=`echo ${first} | sed -e 's/=.*$//' -e 's/?/=/g'`
   r=`echo ${first} | sed -e 's/^.*=//' -e 's/?/=/g'`
   if expr " ${optout} " : ".* ${l} .*" > /dev/null; then
     newopt=`echo " ${optout} " | sed -e "s/ ${l} / ${r} /" -e 's/^ //' -e 's/ $//'`
     dirout="${dirout}" optout="${newopt}" ./tmpmultilib2 $@
   fi
 fi
 EOF
 chmod +x tmpmultilib2

 # Start with the current directory, which includes only negations.
 optout=
 for set in ${options}; do
   for opt in `echo ${set} | sed -e 's_[/|]_ _g'`; do
     optout="${optout} !${opt}"
   done
 done
 optout=`echo ${optout} | sed -e 's/^ //'`
 echo "\".${defaultosdirname} ${optout};\","
 [ -n "${defaultosdirname2}" ] && echo "\".${defaultosdirname2} ${optout};\","

 # This part of code convert an option combination to
 # its corresponding directory names.
 # The directory names will be deduced from MULTILIB_DIRNAMES,
 # MULTILIB_OSDIRNAMES or the option combination itself.
 rm -rf tmpmultilib3
 cat >tmpmultilib3 <<\EOF
 #!/bin/sh

 dirout=
 combo=$1
 todirnames=$2
 toosdirnames=$3
 enable_multilib=$4

 if [ -n "${todirnames}" ]; then
   dirout=`echo ${combo} | sed ${todirnames}`
 else
   dirout=`echo ${combo} | sed -e 's/=/-/g'`
 fi
 # Remove the leading and trailing slashes.
 dirout=`echo ${dirout} | sed -e 's|^/||' -e 's|/*:/*|:|' -e 's|/$||g'`

 # Use the OS directory names rather than the option names.
 if [ -n "${toosdirnames}" ]; then
   osdirout=`echo ${combo} | sed ${toosdirnames}`
   # Remove the leading and trailing slashes.
   osdirout=`echo ${osdirout} | sed -e 's|^/||' -e 's|/*:/*|:|' -e 's|/$||g'`
   if [ "x${enable_multilib}" != xyes ]; then
     dirout=".:${osdirout}"
     disable_multilib=yes
   else
     case "${osdirout}" in
       !*)
 	dirout=`echo ${osdirout} | sed 's/^!//'`
 	;;
        *)
 	dirout="${dirout}:${osdirout}"
 	;;
     esac
   fi
 else
   if [ "x${enable_multilib}" != xyes ]; then
     # genmultilib with --disable-multilib should be
     # called with '' '' '' '' '' '' '' no
     # if MULTILIB_OSDIRNAMES is empty.
     exit 1
   fi
 fi
 echo "${dirout}"
 EOF
 chmod +x tmpmultilib3

 # Script to look through the options and output each option that is present,
 # and negate each option that is not present.
 rm -rf tmpmultilib4
 cat > tmpmultilib4 <<\EOF
 #!/bin/sh

 optout=
 combo=$1
 options=$2

 for set in ${options}; do
   setopts=`echo ${set} | sed -e 's_[/|]_ _g'`
   for opt in ${setopts}; do
     if expr "${combo} " : ".*/${opt}/.*" > /dev/null; then
       optout="${optout} ${opt}"
     else
       optout="${optout} !${opt}"
     fi
   done
 done
 optout=`echo ${optout} | sed -e 's/^ //'`
 echo "${optout}"
 EOF
 chmod +x tmpmultilib4

 # Work over the list of combinations.  We have to translate each one
 # to use the directory names rather than the option names, we have to
 # include the information in matches, and we have to generate the
 # correct list of options and negations.
 for combo in ${combinations}; do
   # Use the directory names rather than the option names.
   dirout=`./tmpmultilib3 "${combo}" "${todirnames}" "${toosdirnames}" "${enable_multilib}"`

   # Look through the options.  We must output each option that is
   # present, and negate each option that is not present.
   optout=`./tmpmultilib4 "${combo}" "${options}"`

   # Output the line with all appropriate matches.
   dirout="${dirout}" optout="${optout}" ./tmpmultilib2
 done

 # Terminate the list of string.
 echo "NULL"
 echo "};"

 # Generate a regular expression to validate option combinations.
 options_re=
 for set in ${options}; do
   for opt in `echo ${set} | sed -e 's_[/|]_ _g' -e 's/+/./g' `; do
     options_re="${options_re}${options_re:+|}${opt}"
   done
 done
 options_re="^/((${options_re})/)*\$"

 # Output rules used for multilib reuse.
 echo ""
 echo "static const char *const multilib_reuse_raw[] = {"
 for rrule in ${multilib_reuse}; do
   # The left part of the rule are the options we used to build multilib.
   # The right part of the rule are the options that can reuse this multilib.
   combo=`echo ${rrule} | sed -e 's/=.*$//' -e 's/\([^\\]\)\./\1=/g' -e 's/\\\././g'`
   copts=`echo ${rrule} | sed -e 's/^.*=//' -e 's/\([^\\]\)\./\1=/g' -e 's/\\\././g'`
   # The variable ${combinations} are the option combinations we will build
   # multilib from.  If the combination in the left part of reuse rule isn't
   # in this variable, it means no multilib will be built for current reuse
   # rule.  Thus the reuse purpose specified by current rule is meaningless.
   if expr "${combinations} " : ".*/${combo}/.*" > /dev/null; then
     if echo "/${copts}/" | grep -E "${options_re}" > /dev/null; then
       combo="/${combo}/"
       dirout=`./tmpmultilib3 "${combo}" "${todirnames}" "${toosdirnames}" "${enable_multilib}"`
       copts="/${copts}/"
       optout=`./tmpmultilib4 "${copts}" "${options}"`
       # Output the line with all appropriate matches.
       dirout="${dirout}" optout="${optout}" ./tmpmultilib2
     else
       echo "The rule ${rrule} contains an option absent from MULTILIB_OPTIONS." >&2
       exit 1
     fi
   else
     echo "The rule ${rrule} is trying to reuse nonexistent multilib." >&2
     exit 1
   fi
 done

 # Terminate the list of string.
 echo "NULL"
 echo "};"

 # Output all of the matches now as option and that is the same as that, with
 # a semicolon trailer.  Include all of the normal options as well.
 # Note, the format of the matches is reversed compared
 # to what we want, so switch them around.
 echo ""
 echo "static const char *const multilib_matches_raw[] = {"
 for match in ${matches}; do
   l=`echo ${match} | sed -e 's/=.*$//' -e 's/?/=/g'`
   r=`echo ${match} | sed -e 's/^.*=//' -e 's/?/=/g'`
   echo "\"${r} ${l};\","
 done
 for set in ${options}; do
   for opt in `echo ${set} | sed -e 's_[/|]_ _'g`; do
     echo "\"${opt} ${opt};\","
   done
 done
 echo "NULL"
 echo "};"

 # Output the default options now
 echo ""
 echo "static const char *multilib_extra = \"${extra}\";"

 # Output the exclusion rules now
 echo ""
 echo "static const char *const multilib_exclusions_raw[] = {"
 for rule in ${exclusions}; do
   s=`echo ${rule} | sed -e 's,/, ,g'`
   echo "\"${s};\","
 done
 echo "NULL"
 echo "};"

 # Output the options now
 moptions=`echo ${options} | sed -e 's,[ 	][ 	]*, ,g'`
 echo ""
 echo "static const char *multilib_options = \"${moptions}\";"

 # Finally output the disable flag if specified
 if [ "x${disable_multilib}" = xyes ]; then
   echo ""
   echo "#define DISABLE_MULTILIB  1"
 fi

 cd ..
 rm -r tmpmultilib.$$

 exit 0
	#!/bin/sh
	# Generates multilib.h.
	# Copyright (C) 1994-2019 Free Software Foundation, Inc.

	#This file is part of GCC.

	#GCC 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, or (at your option) any later
	#version.

	#GCC 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 GCC; see the file COPYING3. If not see
	#<http://www.gnu.org/licenses/>.

	# This shell script produces a header file which the gcc driver
	# program uses to pick which library to use based on the machine
	# specific options that it is given.

	# The first argument is a list of sets of options. The elements in
	# the list are separated by spaces. Within an element, the options
	# are separated by slashes or pipes. No leading dash is used on the
	# options.
	# Each option in a set separated by slashes is mutually incompatible
	# with all other options
	# in the set.
	# Each option in a set separated by pipes will be used for the library
	# compilation and any of the options in the set will be sufficient
	# for it to be triggered.

	# The optional second argument is a list of subdirectory names. If
	# the second argument is non-empty, there must be as many elements in
	# the second argument as there are options in the first argument. The
	# elements in the second list are separated by spaces. If the second
	# argument is empty, the option names will be used as the directory
	# names.

	# The optional third argument is a list of options which are
	# identical. The elements in the list are separated by spaces. Each
	# element must be of the form OPTION=OPTION. The first OPTION should
	# appear in the first argument, and the second should be a synonym for
	# it. Question marks are replaced with equal signs in both options.

	# The optional fourth argument is a list of multilib directory
	# combinations that should not be built.

	# The optional fifth argument is a list of options that should be
	# used whenever building multilib libraries.

	# The optional sixth argument is a list of exclusions used internally by
	# the compiler similar to exceptions. The difference being that exclusions
	# allow matching default options that genmultilib does not know about and
	# is done at runtime as opposed to being sorted out at compile time.
	# Each element in the list is a separate exclusion rule. Each rule is
	# a list of options (sans preceding '-') separated by a '/'. The options
	# on the rule are grouped as an AND operation, and all options much match
	# for the rule to exclude a set. Options can be preceded with a '!' to
	# match a logical NOT.

	# The optional seventh argument is a list of OS subdirectory names.
	# The format is either the same as of the second argument, or a set of
	# mappings. When it is the same as the second argument, it describes
	# the multilib directories using OS conventions, rather than GCC
	# conventions. When it is a set of mappings of the form gccdir=osdir,
	# the left side gives the GCC convention and the right gives the
	# equivalent OS defined location. If the osdir part begins with a !,
	# the os directory names are used exclusively. Use the mapping when
	# there is no one-to-one equivalence between GCC levels and the OS.

	# The optional eighth argument which intends to reduce the effort to write
	# so many MULTILIB_EXCEPTIONS rules. This option defines a series of option
	# combinations that we actually required.
	# For some cases, the generated option combinations are far more than what
	# we need, we have to write a lot of rules to screen out combinations we
	# don't need. If we missed some rules, the unexpected libraries will be built.
	# Now with this argument, one can simply give what combinations are needed.
	# It is pretty straigtforward.
	# This argument can be used together with MULTILIB_EXCEPTIONS and will take
	# effect after the MULTILIB_EXCEPTIONS.

	# The optional ninth argument is the multiarch name.

	# The optional tenth argument specifies how to reuse multilib for different
	# option sets.

	# The last option should be "yes" if multilibs are enabled. If it is not
	# "yes", all GCC multilib dir names will be ".".

	# The output looks like
	# #define MULTILIB_MATCHES "\
	# SUBDIRECTORY OPTIONS;\
	# ...
	# "
	# The SUBDIRECTORY is the subdirectory to use. The OPTIONS are
	# multiple options separated by spaces. Each option may start with an
	# exclamation point. gcc will consider each line in turn. If none of
	# the options beginning with an exclamation point are present, and all
	# of the other options are present, that subdirectory will be used.
	# The order of the subdirectories is such that they can be created in
	# order; that is, a subdirectory is preceded by all its parents.

	# Here is an example (this is from the actual sparc64 case):
	# genmultilib 'm64/m32 mno-app-regs\|mcmodel=medany' '64 32 alt'
	# 'mcmodel?medany=mcmodel?medmid' 'm32/mno-app-regs* m32/mcmodel=*'
	# '' 'm32/!m64/mno-app-regs m32/!m64/mcmodel=medany'
	# '../lib64 ../lib32 alt' '' '' '' yes
	# This produces:
	# ". !m64 !m32 !mno-app-regs !mcmodel=medany;",
	# "64:../lib64 m64 !m32 !mno-app-regs !mcmodel=medany;",
	# "32:../lib32 !m64 m32 !mno-app-regs !mcmodel=medany;",
	# "alt !m64 !m32 mno-app-regs mcmodel=medany;",
	# "alt !m64 !m32 mno-app-regs !mcmodel=medany;",
	# "alt !m64 !m32 !mno-app-regs mcmodel=medany;",
	# "64/alt:../lib64/alt m64 !m32 mno-app-regs mcmodel=medany;",
	# "64/alt:../lib64/alt m64 !m32 mno-app-regs !mcmodel=medany;",
	# "64/alt:../lib64/alt m64 !m32 !mno-app-regs mcmodel=medany;",
	#
	# The effect is that `gcc -mno-app-regs' (for example) will append "alt"
	# to the directory name when searching for libraries or startup files and
	# `gcc -m32 -mcmodel=medany' (for example) will append "32/alt". Also note
	# that exclusion above is moot, unless the compiler had a default of -m32,
	# which would mean that all of the "alt" directories (not the 64/alt ones)
	# would be ignored (not generated, nor used) since the exclusion also
	# matches the multilib_default args.

	# Copy the positional parameters into variables.
	options=$1
	dirnames=$2
	matches=$3
	exceptions=$4
	extra=$5
	exclusions=$6
	osdirnames=$7
	multilib_required=$8
	multiarch=$9
	multilib_reuse=${10}
	enable_multilib=${11}

	echo "static const char *const multilib_raw[] = {"

	mkdir tmpmultilib.$$ \|\| exit 1
	# Use cd ./foo to avoid CDPATH output.
	cd ./tmpmultilib.$$ \|\| exit 1

	# What we want to do is select all combinations of the sets in
	# options. Each combination which includes a set of mutually
	# exclusive options must then be output multiple times, once for each
	# item in the set. Selecting combinations is a recursive process.
	# Since not all versions of sh support functions, we achieve recursion
	# by creating a temporary shell script which invokes itself.
	rm -f tmpmultilib
	cat >tmpmultilib <<\EOF
	#!/bin/sh
	# This recursive script basically outputs all combinations of its
	# input arguments, handling mutually exclusive sets of options by
	# repetition. When the script is called, ${initial} is the list of
	# options which should appear before all combinations this will
	# output. The output looks like a list of subdirectory names with
	# leading and trailing slashes.
	if [ "$#" != "0" ]; then
	first=$1
	shift
	case "$first" in
	\\|)
	all=${initial}`echo $first \| sed -e 's_\|_/_'g`
	first=`echo $first \| sed -e 's_\|_ _'g`
	echo ${all}/
	initial="${initial}${all}/" ./tmpmultilib $@
	./tmpmultilib $first $@ \| grep -v "^${all}"
	;;
	*)
	for opt in `echo $first \| sed -e 's\|/\| \|'g`; do
	echo ${initial}${opt}/
	done
	./tmpmultilib $@
	for opt in `echo $first \| sed -e 's\|/\| \|'g`; do
	initial="${initial}${opt}/" ./tmpmultilib $@
	done
	esac
	fi
	EOF
	chmod +x tmpmultilib

	combinations=`initial=/ ./tmpmultilib ${options}`

	# If there exceptions, weed them out now
	if [ -n "${exceptions}" ]; then
	cat >tmpmultilib2 <<\EOF
	#!/bin/sh
	# This recursive script weeds out any combination of multilib
	# switches that should not be generated. The output looks like
	# a list of subdirectory names with leading and trailing slashes.

	for opt in $@; do
	case "$opt" in
	EOF

	for except in ${exceptions}; do
	echo " /${except}/) : ;;" >> tmpmultilib2
	done

	cat >>tmpmultilib2 <<\EOF
	*) echo ${opt};;
	esac
	done
	EOF
	chmod +x tmpmultilib2
	combinations=`./tmpmultilib2 ${combinations}`
	fi

	# If the MULTILIB_REQUIRED list are provided,
	# filter out combinations not in this list.
	if [ -n "${multilib_required}" ]; then
	cat >tmpmultilib2 <<\EOF
	#!/bin/sh
	# This recursive script weeds out any combination of multilib
	# switches that not in the expected list.

	for opt in $@; do
	case "$opt" in
	EOF

	for expect in ${multilib_required}; do
	echo " /${expect}/) echo \${opt};;" >> tmpmultilib2
	done

	cat >>tmpmultilib2 <<\EOF
	*) ;;
	esac
	done
	EOF

	chmod +x tmpmultilib2
	combinations=`./tmpmultilib2 ${combinations}`

	fi

	# Construct a sed pattern which will convert option names to directory
	# names.
	todirnames=
	if [ -n "${dirnames}" ]; then
	set x ${dirnames}
	shift
	for set in ${options}; do
	for opts in `echo ${set} \| sed -e 's\|/\| \|'g`; do
	patt="/"
	for opt in `echo ${opts} \| sed -e 's_\|_ _'g`; do
	if [ "$1" != "${opt}" ]; then
	todirnames="${todirnames} -e s\|/${opt}/\|/${1}/\|g"
	patt="${patt}${1}/"
	if [ "${patt}" != "/${1}/" ]; then
	todirnames="${todirnames} -e s\|${patt}\|/${1}/\|g"
	fi
	fi
	done
	shift
	done
	done
	fi

	# Construct a sed pattern which will convert option names to OS directory
	# names.
	toosdirnames=
	defaultosdirname=
	defaultosdirname2=
	if [ -n "${multiarch}" ]; then
	defaultosdirname=::${multiarch}
	fi
	if [ -n "${osdirnames}" ]; then
	set x ${osdirnames}
	shift
	while [ $# != 0 ] ; do
	case "$1" in
	.=*)
	defaultosdirname=`echo $1 \| sed 's\|^.=\|:\|'`
	if [ -n "${multiarch}" ]; then
	defaultosdirname=${defaultosdirname}:${multiarch}
	fi
	case "$defaultosdirname" in
	::*) ;;
	*)
	defaultosdirname2=${defaultosdirname}
	defaultosdirname=
	;;
	esac
	shift
	;;
	=)
	patt=`echo $1 \| sed -e 's\|=\|/$=/\|'`
	toosdirnames="${toosdirnames} -e s=^/${patt}/="
	shift
	;;
	*)
	break
	;;
	esac
	done

	if [ $# != 0 ]; then
	for set in ${options}; do
	for opts in `echo ${set} \| sed -e 's\|/\| \|'g`; do
	patt="/"
	for opt in `echo ${opts} \| sed -e 's_\|_ _'g`; do
	if [ "$1" != "${opt}" ]; then
	toosdirnames="${toosdirnames} -e s\|/${opt}/\|/${1}/\|g"
	patt="${patt}${1}/"
	if [ "${patt}" != "/${1}/" ]; then
	toosdirnames="${toosdirnames} -e s\|${patt}\|/${1}/\|g"
	fi
	fi
	done
	shift
	done
	done
	fi
	fi

	# We need another recursive shell script to correctly handle positive
	# matches. If we are invoked as
	# genmultilib "opt1 opt2" "" "opt1=nopt1 opt2=nopt2"
	# we must output
	# opt1/opt2 opt1 opt2
	# opt1/opt2 nopt1 opt2
	# opt1/opt2 opt1 nopt2
	# opt1/opt2 nopt1 nopt2
	# In other words, we must output all combinations of matches.
	rm -f tmpmultilib2
	cat >tmpmultilib2 <<\EOF
	#!/bin/sh
	# The positional parameters are a list of matches to consider.
	# ${dirout} is the directory name and ${optout} is the current list of
	# options.
	if [ "$#" = "0" ]; then
	echo "\"${dirout} ${optout};\","
	else
	first=$1
	shift
	dirout="${dirout}" optout="${optout}" ./tmpmultilib2 $@
	l=`echo ${first} \| sed -e 's/=.*$//' -e 's/?/=/g'`
	r=`echo ${first} \| sed -e 's/^.*=//' -e 's/?/=/g'`
	if expr " ${optout} " : ".* ${l} .*" > /dev/null; then
	newopt=`echo " ${optout} " \| sed -e "s/ ${l} / ${r} /" -e 's/^ //' -e 's/ $//'`
	dirout="${dirout}" optout="${newopt}" ./tmpmultilib2 $@
	fi
	fi
	EOF
	chmod +x tmpmultilib2

	# Start with the current directory, which includes only negations.
	optout=
	for set in ${options}; do
	for opt in `echo ${set} \| sed -e 's_[/\|]_ _g'`; do
	optout="${optout} !${opt}"
	done
	done
	optout=`echo ${optout} \| sed -e 's/^ //'`
	echo "\".${defaultosdirname} ${optout};\","
	[ -n "${defaultosdirname2}" ] && echo "\".${defaultosdirname2} ${optout};\","

	# This part of code convert an option combination to
	# its corresponding directory names.
	# The directory names will be deduced from MULTILIB_DIRNAMES,
	# MULTILIB_OSDIRNAMES or the option combination itself.
	rm -rf tmpmultilib3
	cat >tmpmultilib3 <<\EOF
	#!/bin/sh

	dirout=
	combo=$1
	todirnames=$2
	toosdirnames=$3
	enable_multilib=$4

	if [ -n "${todirnames}" ]; then
	dirout=`echo ${combo} \| sed ${todirnames}`
	else
	dirout=`echo ${combo} \| sed -e 's/=/-/g'`
	fi
	# Remove the leading and trailing slashes.
	dirout=`echo ${dirout} \| sed -e 's\|^/\|\|' -e 's\|/:/\|:\|' -e 's\|/$\|\|g'`

	# Use the OS directory names rather than the option names.
	if [ -n "${toosdirnames}" ]; then
	osdirout=`echo ${combo} \| sed ${toosdirnames}`
	# Remove the leading and trailing slashes.
	osdirout=`echo ${osdirout} \| sed -e 's\|^/\|\|' -e 's\|/:/\|:\|' -e 's\|/$\|\|g'`
	if [ "x${enable_multilib}" != xyes ]; then
	dirout=".:${osdirout}"
	disable_multilib=yes
	else
	case "${osdirout}" in
	!*)
	dirout=`echo ${osdirout} \| sed 's/^!//'`
	;;
	*)
	dirout="${dirout}:${osdirout}"
	;;
	esac
	fi
	else
	if [ "x${enable_multilib}" != xyes ]; then
	# genmultilib with --disable-multilib should be
	# called with '' '' '' '' '' '' '' no
	# if MULTILIB_OSDIRNAMES is empty.
	exit 1
	fi
	fi
	echo "${dirout}"
	EOF
	chmod +x tmpmultilib3

	# Script to look through the options and output each option that is present,
	# and negate each option that is not present.
	rm -rf tmpmultilib4
	cat > tmpmultilib4 <<\EOF
	#!/bin/sh

	optout=
	combo=$1
	options=$2

	for set in ${options}; do
	setopts=`echo ${set} \| sed -e 's_[/\|]_ _g'`
	for opt in ${setopts}; do
	if expr "${combo} " : "./${opt}/." > /dev/null; then
	optout="${optout} ${opt}"
	else
	optout="${optout} !${opt}"
	fi
	done
	done
	optout=`echo ${optout} \| sed -e 's/^ //'`
	echo "${optout}"
	EOF
	chmod +x tmpmultilib4

	# Work over the list of combinations. We have to translate each one
	# to use the directory names rather than the option names, we have to
	# include the information in matches, and we have to generate the
	# correct list of options and negations.
	for combo in ${combinations}; do
	# Use the directory names rather than the option names.
	dirout=`./tmpmultilib3 "${combo}" "${todirnames}" "${toosdirnames}" "${enable_multilib}"`

	# Look through the options. We must output each option that is
	# present, and negate each option that is not present.
	optout=`./tmpmultilib4 "${combo}" "${options}"`

	# Output the line with all appropriate matches.
	dirout="${dirout}" optout="${optout}" ./tmpmultilib2
	done

	# Terminate the list of string.
	echo "NULL"
	echo "};"

	# Generate a regular expression to validate option combinations.
	options_re=
	for set in ${options}; do
	for opt in `echo ${set} \| sed -e 's_[/\|]_ _g' -e 's/+/./g' `; do
	options_re="${options_re}${options_re:+\|}${opt}"
	done
	done
	options_re="^/((${options_re})/)*\$"

	# Output rules used for multilib reuse.
	echo ""
	echo "static const char *const multilib_reuse_raw[] = {"
	for rrule in ${multilib_reuse}; do
	# The left part of the rule are the options we used to build multilib.
	# The right part of the rule are the options that can reuse this multilib.
	combo=`echo ${rrule} \| sed -e 's/=.*$//' -e 's/\([^\\]\)\./\1=/g' -e 's/\\\././g'`
	copts=`echo ${rrule} \| sed -e 's/^.*=//' -e 's/\([^\\]\)\./\1=/g' -e 's/\\\././g'`
	# The variable ${combinations} are the option combinations we will build
	# multilib from. If the combination in the left part of reuse rule isn't
	# in this variable, it means no multilib will be built for current reuse
	# rule. Thus the reuse purpose specified by current rule is meaningless.
	if expr "${combinations} " : "./${combo}/." > /dev/null; then
	if echo "/${copts}/" \| grep -E "${options_re}" > /dev/null; then
	combo="/${combo}/"
	dirout=`./tmpmultilib3 "${combo}" "${todirnames}" "${toosdirnames}" "${enable_multilib}"`
	copts="/${copts}/"
	optout=`./tmpmultilib4 "${copts}" "${options}"`
	# Output the line with all appropriate matches.
	dirout="${dirout}" optout="${optout}" ./tmpmultilib2
	else
	echo "The rule ${rrule} contains an option absent from MULTILIB_OPTIONS." >&2
	exit 1
	fi
	else
	echo "The rule ${rrule} is trying to reuse nonexistent multilib." >&2
	exit 1
	fi
	done

	# Terminate the list of string.
	echo "NULL"
	echo "};"

	# Output all of the matches now as option and that is the same as that, with
	# a semicolon trailer. Include all of the normal options as well.
	# Note, the format of the matches is reversed compared
	# to what we want, so switch them around.
	echo ""
	echo "static const char *const multilib_matches_raw[] = {"
	for match in ${matches}; do
	l=`echo ${match} \| sed -e 's/=.*$//' -e 's/?/=/g'`
	r=`echo ${match} \| sed -e 's/^.*=//' -e 's/?/=/g'`
	echo "\"${r} ${l};\","
	done
	for set in ${options}; do
	for opt in `echo ${set} \| sed -e 's_[/\|]_ _'g`; do
	echo "\"${opt} ${opt};\","
	done
	done
	echo "NULL"
	echo "};"

	# Output the default options now
	echo ""
	echo "static const char *multilib_extra = \"${extra}\";"

	# Output the exclusion rules now
	echo ""
	echo "static const char *const multilib_exclusions_raw[] = {"
	for rule in ${exclusions}; do
	s=`echo ${rule} \| sed -e 's,/, ,g'`
	echo "\"${s};\","
	done
	echo "NULL"
	echo "};"

	# Output the options now
	moptions=`echo ${options} \| sed -e 's,[ ][ ]*, ,g'`
	echo ""
	echo "static const char *multilib_options = \"${moptions}\";"

	# Finally output the disable flag if specified
	if [ "x${disable_multilib}" = xyes ]; then
	echo ""
	echo "#define DISABLE_MULTILIB 1"
	fi

	cd ..
	rm -r tmpmultilib.$$

	exit 0