path: root/gcc-4.2.1/gcc/mklibgcc.in

#!/bin/sh
# Construct makefile for libgcc.
#   Copyright (C) 2000, 2002, 2003, 2004, 2005, 2006
#   Free Software Foundation, Inc.
#
# This file is part of GCC.

# Arguments, taken from the environment, since there are a lot
# of them, and positional args becomes quite ugly.
#
# objext
# LIB1ASMFUNCS
# LIB2FUNCS_ST
# LIB2FUNCS_EXCLUDE
# LIBGCOV
# LIB2ADD
# LIB2ADD_ST 
# LIB2ADDEH
# LIB2ADDEHSTATIC
# LIB2ADDEHSHARED
# LIB2ADDEHDEP
# LIBUNWIND
# LIBUNWINDDEP
# SHLIBUNWIND_LINK
# SHLIBUNWIND_INSTALL
# FPBIT
# FPBIT_FUNCS
# LIB2_DIVMOD_FUNCS
# LIB2_SIDITI_CONV_FUNCS
# DFP_ENABLE
# DFP_CFLAGS
# DPBIT
# DPBIT_FUNCS
# TPBIT
# TPBIT_FUNCS
# D32PBIT
# D32PBIT_FUNCS
# D64PBIT
# D64PBIT_FUNCS
# D128PBIT
# D128PBIT_FUNCS
# LIBGCC
# MULTILIBS
# EXTRA_MULTILIB_PARTS
# SHLIB_EXT
# SHLIB_LINK
# SHLIB_MKMAP
# SHLIB_MKMAP_OPTS
# SHLIB_MAPFILES
# SHLIB_NM_FLAGS
# SHLIB_INSTALL
# MULTILIB_OSDIRNAMES
# ASM_HIDDEN_OP
# GCC_FOR_TARGET

# Make needs VPATH to be literal.
echo 'srcdir = @srcdir@'
echo 'VPATH = @srcdir@'
echo 'EQ = ='
echo 'objects = $(filter %'$objext',$^)'
echo
echo '# Dependencies are accumulated as we go.'
echo 'all: stmp-dirs'
echo 'dirs = libgcc'
echo

# Library members defined in libgcc2.c.

# The floating-point conversion routines that involve a single-word integer.
# XX stands for the integer mode.
swfloatfuncs=
for mode in sf df xf; do
  swfloatfuncs="$swfloatfuncs _fixuns${mode}XX"
done

# Likewise double-word routines.
dwfloatfuncs=
for mode in sf df xf tf; do
  dwfloatfuncs="$dwfloatfuncs _fix${mode}XX _fixuns${mode}XX"
  dwfloatfuncs="$dwfloatfuncs _floatXX${mode} _floatunXX${mode}"
done

# Entries of the form <objfile>:<func>:<wordsize> indicate that libgcc2.c
# should be compiled with L<func> defined and with LIBGCC2_UNITS_PER_WORD
# set to <wordsize>.  <objfile> is the name of the associated object file

lib2funcs='_muldi3 _negdi2 _lshrdi3 _ashldi3 _ashrdi3
	_cmpdi2 _ucmpdi2 _clear_cache
	_enable_execute_stack _trampoline __main _absvsi2 _absvdi2 _addvsi3
	_addvdi3 _subvsi3 _subvdi3 _mulvsi3 _mulvdi3 _negvsi2 _negvdi2 _ctors
	_ffssi2 _ffsdi2 _clz _clzsi2 _clzdi2 _ctzsi2 _ctzdi2 _popcount_tab
	_popcountsi2 _popcountdi2 _paritysi2 _paritydi2 _powisf2 _powidf2
	_powixf2 _powitf2 _mulsc3 _muldc3 _mulxc3 _multc3 _divsc3 _divdc3
	_divxc3 _divtc3'

if [ "$LIB2_SIDITI_CONV_FUNCS" ]; then
  for func in $swfloatfuncs; do
    sifunc=`echo $func | sed -e 's/XX/si/'`
    lib2funcs="$lib2funcs $sifunc:$sifunc:4"
  done
  for func in $dwfloatfuncs; do
    difunc=`echo $func | sed -e 's/XX/di/'`
    tifunc=`echo $func | sed -e 's/XX/ti/'`
    lib2funcs="$lib2funcs $difunc:$difunc:4 $tifunc:$difunc:8"
  done
else
  lib2funcs="$lib2funcs `echo $swfloatfuncs | sed -e 's/XX/si/g'`"
  lib2funcs="$lib2funcs `echo $dwfloatfuncs | sed -e 's/XX/di/g'`"
fi

# Disable SHLIB_LINK if shared libgcc not enabled.
if [ "@enable_shared@" = "no" ]; then
  SHLIB_LINK=""
fi

# Build lines.

gcc_compile='$(GCC_FOR_TARGET) $(LIBGCC2_CFLAGS) $(INCLUDES)'
gcc_s_compile="$gcc_compile -DSHARED"
make_compile='$(MAKE) GCC_FOR_TARGET="$(GCC_FOR_TARGET)" \
	  AR_FOR_TARGET="$(AR_FOR_TARGET)" \
	  AR_CREATE_FOR_TARGET="$(AR_CREATE_FOR_TARGET)" \
	  AR_EXTRACT_FOR_TARGET="$(AR_EXTRACT_FOR_TARGET)" \
	  AR_FLAGS_FOR_TARGET="$(AR_FLAGS_FOR_TARGET)" \
	  CC="$(CC)" CFLAGS="$(CFLAGS)" \
	  BUILD_PREFIX="$(BUILD_PREFIX)" \
	  BUILD_PREFIX_1="$(BUILD_PREFIX_1)" \
	  LANGUAGES="$(LANGUAGES)"'

# Generic dependencies for libgcc
libgcc_dep='$(CONFIG_H) coretypes.h $(TM_H) $(MACHMODE_H) longlong.h config.status stmp-int-hdrs tsystem.h'

# Dependencies for libgcc2.c
libgcc2_c_dep='stmp-dirs $(srcdir)/libgcc2.c $(srcdir)/libgcc2.h gbl-ctors.h'" $libgcc_dep"

# Dependencies for libgcov.c
libgcov_c_dep='stmp-dirs $(srcdir)/libgcov.c $(srcdir)/gcov-io.h $(srcdir)/gcov-io.c gcov-iov.h'" $libgcc_dep"

# Dependencies for fp-bit.c
fpbit_c_dep='stmp-dirs config.status tsystem.h'

# Dependencies for decnumber and friends.  This is an overzealous set,
# but at least we can be sure to recompile if anything gets modified.
decnumber_dep='stmp-dirs $(srcdir)/../libdecnumber/decContext.h $(srcdir)/../libdecnumber/decNumber.h
	$(srcdir)/../libdecnumber/decNumberLocal.h $(srcdir)/../libdecnumber/decimal32.h $(srcdir)/../libdecnumber/decimal64.h
	$(srcdir)/../libdecnumber/decimal128.h $(srcdir)/../libdecnumber/decDPD.h $(srcdir)/../libdecnumber/decUtility.h'

# Flag whether we need eh_dummy.c
need_eh_dummy=

if [ "$SHLIB_LINK" ]; then
  # Test -fvisibility=hidden.  We need both a -fvisibility=hidden on
  # the command line, and a #define to prevent libgcc2.h etc from
  # overriding that with #pragmas.  The dance with @ is to prevent
  # echo from seeing anything it might take for an option.
  # echo turns the \$\$\$\$ into $$$$ and when make sees it it
  # becomes $$ and the shell substitutes the pid. Makes for a
  # slightly safer temp file.
  echo "vis_hide := \$(strip \$(subst @,-,\\"
  echo "    \$(shell if echo 'void foo(void); void foo(void) {}' | \\"
  echo "          $gcc_compile -fvisibility=hidden -Werror \\"
  echo "          -c -xc - -o vis_temp_file\$\$\$\$.o 2> /dev/null; \\"
  echo "          then echo @fvisibility=hidden @DHIDE_EXPORTS; \\"
  echo "          rm vis_temp_file\$\$\$\$.o 2> /dev/null; \\"
  echo "          fi)))"
  echo

  # If we have -fvisibility=hidden, then we need to generate hide
  # lists for object files implemented in assembly.  The default
  # pseudo-op for this is ".hidden", but can be overridden with
  # ASM_HIDDEN_OP.
  [ "$ASM_HIDDEN_OP" ] || ASM_HIDDEN_OP=".hidden"
  
  echo "ifneq (,\$(vis_hide))"
  echo "define gen-hide-list"
  echo "\$(NM_FOR_TARGET) ${SHLIB_NM_FLAGS} \$< | \\"
  # non-GNU nm emits three fields even for undefined and typeless symbols,
  # so explicitly omit them
  echo "  \$(AWK) 'NF == 3 && \$\$2 !~ /^[UN]\$\$/ { print \"\\t${ASM_HIDDEN_OP}\", \$\$3 }' > \$@T"
  echo "mv -f \$@T \$@"
  echo "endef"
  echo "else"
  echo "gen-hide-list = echo > \$@"
  echo "endif"
  echo
else
  # It is too hard to guarantee that vis_hide and gen-hide-list will never
  # be referenced if SHLIB_LINK is not set, so set them to the values they'd
  # have if SHLIB_LINK were set and we didn't have visibility support.
  echo "vis_hide ="
  echo "gen-hide-list = echo > \$@"
fi

# Remove any objects from lib2funcs and LIB2_DIVMOD_FUNCS that are
# defined as optimized assembly code in LIB1ASMFUNCS or as C code
# in LIB2FUNCS_EXCLUDE.
for name in $LIB1ASMFUNCS $LIB2FUNCS_EXCLUDE; do
  lib2funcs=`echo $lib2funcs | sed -e 's/^'$name'[ :]//' \
				   -e 's/ '$name'[ :]/ /' \
				   -e 's/ '$name'$//'`
  LIB2_DIVMOD_FUNCS=`echo $LIB2_DIVMOD_FUNCS | sed -e 's/^'$name' //' \
				                   -e 's/ '$name' / /' \
				                   -e 's/ '$name'$//'`
done

#
# Rules to generate object files.
#

for ml in $MULTILIBS; do

  # Work out relevant parameters that depend only on the multilib.
  dir=`echo ${ml} | sed -e 's/;.*$//' -e 's/=/$(EQ)/g'`
  flags=`echo ${ml} | sed -e 's/^[^;]*;//' -e 's/@/ -/g'`;
  shlib_slibdir_qual=
  libgcc_a=$dir/libgcc.a
  libgcov_a=$dir/libgcov.a
  libgcc_eh_a=
  libgcc_s_so=
  libunwind_a=
  libunwind_so=

  if [ "$LIBUNWIND" ]; then
    libunwind_a=$dir/libunwind.a
  fi
  if [ "$SHLIB_LINK" ]; then
    libgcc_eh_a=$dir/libgcc_eh.a
    libgcc_s_so=$dir/libgcc_s${SHLIB_EXT}
    if [ "$LIBUNWIND" ]; then
      libunwind_so=$dir/libunwind${SHLIB_EXT}
    fi
    os_multilib_dir=`$GCC_FOR_TARGET $flags --print-multi-os-directory`
    if [ "$os_multilib_dir" != . ]; then
      shlib_slibdir_qual="/$os_multilib_dir"
    fi
  fi

  libgcc_s_so_extra=
  libunwind_so_extra=

  echo
  echo \#
  echo \# ml: $ml
  echo \# dir: $dir
  echo \# flags: $flags
  echo \# libgcc_a: $libgcc_a
  echo \# libgcov_a: $libgcov_a
  echo \# libgcc_eh_a: $libgcc_eh_a
  echo \# libunwind_a: $libunwind_a
  echo \#
  echo \# shlib_slibdir_qual: $shlib_slibdir_qual
  echo \# libgcc_s_so: $libgcc_s_so
  echo \# libunwind_so: $libunwind_so
  echo \#
  echo

  # Update list of directories.
  if [ $dir != . ]; then
    echo "dirs += ${dir} libgcc/${dir}"
    echo
  fi

  #
  # Build libgcc1 components.
  #
  for name in $LIB1ASMFUNCS; do
    if [ "$libgcc_s_so" ]; then
      out="libgcc/${dir}/${name}${objext}"
      outS="libgcc/${dir}/${name}_s${objext}"
      outV="libgcc/${dir}/${name}.vis"

      echo ${outS}: stmp-dirs '$(srcdir)/config/$(LIB1ASMSRC)'
      echo "	$gcc_s_compile" $flags -DL$name -xassembler-with-cpp \
	  -c '$(srcdir)/config/$(LIB1ASMSRC)' -o $outS

      echo ${out}: stmp-dirs '$(srcdir)/config/$(LIB1ASMSRC)' ${outV}
      echo "	$gcc_compile" $flags -DL$name -xassembler-with-cpp \
	  -c '$(srcdir)/config/$(LIB1ASMSRC)' -include $outV -o $out

      echo "${outV}: ${outS}; \$(gen-hide-list)"

      echo $libgcc_a: $out
      echo $libgcc_s_so: $outS
      if [ "$SHLIB_MKMAP" ]; then
        echo libgcc/${dir}/libgcc.map: $outS
      fi
    else
      out="libgcc/${dir}/${name}${objext}"
      echo ${out}: stmp-dirs '$(srcdir)/config/$(LIB1ASMSRC)'
      echo "	$gcc_compile" $flags -DL$name -xassembler-with-cpp \
	  -c '$(srcdir)/config/$(LIB1ASMSRC)' -o $out
      echo $libgcc_a: $out
    fi
  done

  #
  # Build libgcc2 components.
  #

  for name in $lib2funcs; do
    case $name in
      *:*:*)
	defines=`echo $name | sed -e 's/.*:\(.*\):\(.*\)/-DL\1 -DLIBGCC2_UNITS_PER_WORD=\2/'`
	name=`echo $name | sed -e 's/\(.*\):.*:.*/\1/'`
	;;
      *)
	defines="-DL$name"
	;;
    esac
    if [ "$libgcc_s_so" ]; then
      out="libgcc/${dir}/${name}${objext}"
      outS="libgcc/${dir}/${name}_s${objext}"

      echo $outS: $libgcc2_c_dep
      echo "	$gcc_s_compile" $flags $defines -c '$(srcdir)/libgcc2.c' \
	-o $outS

      echo $out: $libgcc2_c_dep
      echo "	$gcc_compile" $flags $defines '$(vis_hide)' \
        -c '$(srcdir)/libgcc2.c' -o $out

      echo $libgcc_a: $out
      echo $libgcc_s_so: $outS
      if [ "$SHLIB_MKMAP" ]; then
        echo libgcc/${dir}/libgcc.map: $outS
      fi
    else
      out="libgcc/${dir}/${name}${objext}"
      echo ${out}: stmp-dirs '$(srcdir)/config/$(LIB1ASMSRC)'
      echo "	$gcc_compile" $flags $defines -c '$(srcdir)/libgcc2.c' -o $out
      echo $libgcc_a: $out
    fi
  done

  for name in $LIB2FUNCS_ST; do
    out="libgcc/${dir}/${name}${objext}"

    echo $out: $libgcc2_c_dep
    echo "	$gcc_compile" $flags -DL$name '$(vis_hide)' \
      -c '$(srcdir)/libgcc2.c' -o $out
    echo ${dir}/libgcc.a: $out
  done

  for name in $LIB2_DIVMOD_FUNCS; do
    if [ "$libgcc_s_so" ]; then
      out="libgcc/${dir}/${name}${objext}"
      outS="libgcc/${dir}/${name}_s${objext}"

      echo $outS: $libgcc2_c_dep
      echo "	$gcc_s_compile" $flags -DL$name \
        -fexceptions -fnon-call-exceptions -c '$(srcdir)/libgcc2.c' -o $outS

      echo $out: $libgcc2_c_dep
      echo "	$gcc_compile" $flags -DL$name '$(vis_hide)' \
        -fexceptions -fnon-call-exceptions -c '$(srcdir)/libgcc2.c' -o $out

      echo $libgcc_a: $out
      echo $libgcc_s_so: $outS
      if [ "$SHLIB_MKMAP" ]; then
        echo libgcc/${dir}/libgcc.map: $outS
      fi
    else
      out="libgcc/${dir}/${name}${objext}"
      echo ${out}: stmp-dirs '$(srcdir)/config/$(LIB1ASMSRC)'
      echo "	$gcc_compile" $flags -DL$name \
        -fexceptions -fnon-call-exceptions -c '$(srcdir)/libgcc2.c' -o $out
      echo $libgcc_a: $out
    fi
  done

  #
  # Build software floating point functions.
  #

  for fpbit_var in FPBIT DPBIT TPBIT ; do
      fpfuncs_var="${fpbit_var}_FUNCS"
      eval fpbit=\$$fpbit_var
      eval fpfuncs=\$$fpfuncs_var

      if [ "$fpbit" ] ; then
	  for name in $fpfuncs; do
	      case "$name" in
		# _sf_to_tf and _df_to_tf require tp-bit.c
		# being compiled in.
		_[sd]f_to_tf) [ -z "$TPBIT" ] && continue;;
	      esac
	      if [ "$libgcc_s_so" ]; then
		  out="libgcc/${dir}/${name}${objext}"
		  outS="libgcc/${dir}/${name}_s${objext}"

		  echo $outS: $fpbit $fpbit_c_dep
		  echo "	$gcc_s_compile" -DFINE_GRAINED_LIBRARIES $flags -DL$name \
		      -c $fpbit -o $outS

		  echo $out: $fpbit $fpbit_c_dep
		  echo "	$gcc_compile" -DFINE_GRAINED_LIBRARIES $flags -DL$name \
		      '$(vis_hide)' -c $fpbit -o $out
		  
		  echo $libgcc_a: $out
		  echo $libgcc_s_so: $outS
		  if [ "$SHLIB_MKMAP" ]; then
		      echo libgcc/${dir}/libgcc.map: $outS
		  fi
	      else
		  out="libgcc/${dir}/${name}${objext}"
		  echo $out: $fpbit $fpbit_c_dep
		  echo "	$gcc_compile" -DFINE_GRAINED_LIBRARIES $flags -DL$name \
		      -c $fpbit -o $out
		  
		  echo $libgcc_a: $out
	      fi
	  done
      fi
  done

  if [ "@enable_decimal_float@" = "yes" -a -z "$libgcc_so" ]; then
    # If $DFP_ENABLE is set, then we want all data type sizes.
    if [ "$DFP_ENABLE" ] ; then
	D32PBIT=1; D64PBIT=1; D128PBIT=1
    fi

    # Bring in the DFP support code if D32PBIT, D64PBIT or D128PBIT are set.
    if [ -n "$D32PBIT" -o -n "$D64PBIT" -o -n "$D128PBIT" ] ; then
      dec_filenames="decContext decNumber decRound decLibrary decUtility"
    fi

    # Only bring in decimal*.c files for types we support.
    if [ -n "$D32PBIT" ] ; then
      dec_filenames="$dec_filenames decimal32"
    fi
    if [ -n "$D64PBIT" ] ; then
      dec_filenames="$dec_filenames decimal64"
    fi
    if [ -n "$D128PBIT" ] ; then
      dec_filenames="$dec_filenames decimal128"
    fi

    for name in $dec_filenames ; do
      out="libgcc/${dir}/${name}${objext}"
      echo $out: "\$(srcdir)/../libdecnumber/${name}.c" $decnumber_dep
      echo "	$gcc_compile" $flags -c "\$(srcdir)/../libdecnumber/${name}.c" -o $out
      echo $libgcc_a: $out
    done

    # For individual functions, loop over each variable by name.
    for dpbit_var in D32PBIT D64PBIT D128PBIT ; do
      dpfuncs_var="${dpbit_var}_FUNCS"
      eval dpbit=\$$dpbit_var
      eval dpfuncs=\$$dpfuncs_var
      case "$dpbit_var" in
	  D32PBIT)  dpwidth=32 ;;
	  D64PBIT)  dpwidth=64 ;;
	  D128PBIT) dpwidth=128 ;;
      esac

      if [ "$dpbit" ]; then
        for name in $dpfuncs; do
          out="libgcc/${dir}/${name}${objext}"
	  echo $out: config/dfp-bit.h config/dfp-bit.c $fpbit_c_dep
	  echo "	$gcc_compile" -DFINE_GRAINED_LIBRARIES $flags -DL$name -DWIDTH=$dpwidth \
	      $DFP_CFLAGS -c $\(srcdir\)/config/dfp-bit.c -o $out
	  echo $libgcc_a: $out
        done
      fi
    done
  fi

  for file in $LIB2ADD; do
    name=`echo $file | sed -e 's/[.][cS]$//' -e 's/[.]asm$//'`
    oname=`echo $name | sed -e 's,.*/,,'`

    if [ "$libgcc_s_so" ]; then
      out="libgcc/${dir}/${oname}${objext}"
      outS="libgcc/${dir}/${oname}_s${objext}"

      case $file in
	*.c)
	  echo $outS: stmp-dirs $file $libgcc_dep
	  echo "	$gcc_s_compile" $flags -c $file -o $outS

	  echo $out: stmp-dirs $file $libgcc_dep
	  echo "	$gcc_compile" $flags '$(vis_hide)' -c $file -o $out
	;;

	*.asm | *.S)
	  outV="libgcc/${dir}/${oname}.vis"

	  echo $outS: stmp-dirs $file $libgcc_dep
	  echo "	$gcc_s_compile" $flags -xassembler-with-cpp \
	         -c $file -o $outS

	  echo $out: stmp-dirs $file $libgcc_dep $outV
	  echo "	$gcc_compile" $flags -xassembler-with-cpp \
	         -include $outV -c $file -o $out
	  echo "${outV}: ${outS}; \$(gen-hide-list)"
	;;
	
        *)
	  echo "Unhandled extension: $file" >&2
	  exit 1
	;;
      esac

      echo $libgcc_a: $out
      echo $libgcc_s_so: $outS
      if [ "$SHLIB_MKMAP" ]; then
	echo libgcc/${dir}/libgcc.map: $outS
      fi
    else
      out="libgcc/${dir}/${oname}${objext}"
      case $file in
	*.c)
	  echo $out: stmp-dirs $file $libgcc_dep
	  echo "	$gcc_compile" $flags -c $file -o $out
	;;

	*.asm | *.S)
	  echo $out: stmp-dirs $file $libgcc_dep
	  echo "	$gcc_compile" $flags -xassembler-with-cpp \
	         -c $file -o $out
	;;
	
        *)
	  echo "Unhandled extension: $file" >&2
	  exit 1
	;;
      esac
      
      echo $libgcc_a: $out
    fi
  done


  for file in $LIB2ADD_ST; do
    name=`echo $file | sed -e 's/[.][cSo]$//' -e 's/[.]asm$//'`
    oname=`echo $name | sed -e 's,.*/,,'`
    out="libgcc/${dir}/${oname}${objext}"

    case $file in
      *.c)
	echo $out: stmp-dirs $file $libgcc_dep
	echo "	$gcc_compile" $flags '$(vis_hide)' -c $file -o $out
      ;;

      *.asm | *.S)
        # We may have to compile it twice in order to establish the list
        # of symbols to be marked hidden.
	if [ "$libgcc_so" ]; then
	  outV="libgcc/${dir}/${oname}.vis"
	  outT="libgcc/${dir}/${oname}_t${objext}"
	  echo ${outT}: stmp-dirs $file $libgcc_dep
	  echo "	$gcc_compile" $flags -xassembler-with-cpp \
	          -c $file -o ${outT}
	  echo $out: stmp-dirs $file $libgcc_dep $outV
	  echo "	$gcc_compile" $flags -xassembler-with-cpp \
	          -include $outV -c $file -o $out
	  echo "${outV}: ${outT}; \$(gen-hide-list)"
	else
	  echo $out: stmp-dirs $file $libgcc_dep
	  echo "	$gcc_compile" $flags -xassembler-with-cpp \
	          -c $file -o $out
	fi
      ;;

      *)
      echo "Unhandled extension: $file" >&2
      exit 1
      ;;
    esac
    echo $libgcc_a: $out
  done

  # If we don't have libgcc_eh.a, only LIB2ADDEH matters.  If we do, only
  # LIB2ADDEHSTATIC and LIB2ADDEHSHARED matter.  (Usually all three are
  # identical.)

  if [ "$libgcc_eh_a" ]; then
    for file in $LIB2ADDEHSTATIC; do
      name=`echo $file | sed -e 's/[.][cSo]$//' -e 's/[.]asm$//'`
      oname=`echo $name | sed -e 's,.*/,,'`
      out="libgcc/${dir}/${oname}${objext}"

      case $file in
        *.c)
	  echo $out: stmp-dirs $file $LIB2ADDEHDEP $libgcc_dep
	  echo "	$gcc_compile" $flags -fexceptions '$(vis_hide)' -c $file -o $out
	  ;;
	*.asm | *.S)
	  # We have to compile it twice in order to establish the list
	  # of symbols to be marked hidden.
	  outV="libgcc/${dir}/${oname}.vis"
	  outT="libgcc/${dir}/${oname}_t${objext}"
	  echo ${outT}: stmp-dirs $file $LIB2ADDEHDEP $libgcc_dep
	  echo "	$gcc_compile" $flags -xassembler-with-cpp \
		  -c $file -o ${outT}
	  echo $out: stmp-dirs $file $LIB2ADDEHDEP $libgcc_dep $outV
	  echo "	$gcc_compile" $flags -xassembler-with-cpp \
		  -include $outV -c $file -o $out
	  echo "${outV}: ${outT}; \$(gen-hide-list)"
	  ;;
	*)   echo "Unhandled extension: $file">&2; exit 1 ;;
      esac

      echo $libgcc_eh_a: $out
    done

    for file in $LIB2ADDEHSHARED; do
      name=`echo $file | sed -e 's/[.][cSo]$//' -e 's/[.]asm$//'`
      oname=`echo $name | sed -e 's,.*/,,'`
      outS="libgcc/${dir}/${oname}_s${objext}"

      case $file in
        *.c)
	  echo $outS: stmp-dirs $file $LIB2ADDEHDEP $libgcc_dep
	  echo "	$gcc_s_compile" $flags -fexceptions -c $file -o $outS
	  ;;
	*.asm | *.S)
	  echo $outS: stmp-dirs $file $LIB2ADDEHDEP $libgcc_dep
	  echo "	$gcc_s_compile" $flags -xassembler-with-cpp -c $file -o $outS
	  ;;
	*)   echo "Unhandled extension: $file">&2; exit 1 ;;
      esac

      echo $libgcc_s_so: $outS
      if [ "$SHLIB_MKMAP" ]; then
	echo libgcc/${dir}/libgcc.map: $outS
      fi
    done

    # If nothing went into libgcc_eh.a, create a dummy object -
    # some linkers don't like totally empty archives.
    if [ -z "$LIB2ADDEHSTATIC" ]; then
      file=eh_dummy.c
      out="libgcc/${dir}/eh_dummy${objext}"
      need_eh_dummy=1

      echo $out: stmp-dirs $file
      echo "	$gcc_compile" $flags '$(vis_hide)' -fexceptions -c $file -o $out
      echo $libgcc_eh_a: $out
    fi
   

  else # no libgcc_eh.a
    for file in $LIB2ADDEH; do
      name=`echo $file | sed -e 's/[.][cSo]$//' -e 's/[.]asm$//'`
      oname=`echo $name | sed -e 's,.*/,,'`
      out="libgcc/${dir}/${oname}${objext}"

      case $file in
        *.c)
	  echo $out: stmp-dirs $file $LIB2ADDEHDEP $libgcc_dep
	  echo "	$gcc_compile" $flags '$(vis_hide)' -fexceptions -c $file -o $out
	  ;;
	*.asm | *.S)
	  echo $out: stmp-dirs $file $LIB2ADDEHDEP $libgcc_dep
	  echo "	$gcc_compile" $flags -xassembler-with-cpp \
		  -c $file -o $out
	  ;;
	*)   echo "Unhandled extension: $file">&2; exit 1 ;;
      esac

      echo $libgcc_a: $out
    done
  fi

  # We do _not_ handle assembly files in this context.
  if [ "$LIBUNWIND" ]; then
    for file in $LIBUNWIND; do
      case $file in
        *.c) ;;
	*)   echo "Unhandled extension: $file">&2; exit 1 ;;
       esac

      name=`echo $file | sed -e 's/[.]c$//'`
      oname=`echo $name | sed -e 's,.*/,,'`

      if [ "$libunwind_so" ]; then
        out="libgcc/${dir}/${oname}${objext}"
	outS="libgcc/${dir}/${oname}_s${objext}"

	echo $out: stmp-dirs $file $LIBUNWINDDEP
	echo "	$gcc_compile $flags -fexceptions \$(vis_hide) -c $file -o $out"

	echo $outS: stmp-dirs $file $LIBUNWINDDEP
	echo "	$gcc_s_compile $flags -fexceptions -c $file -o $outS"

	echo $libunwind_a: $out
	echo $libunwind_so: $outS
      else
        out="libgcc/${dir}/${oname}${objext}"
	echo $out: stmp-dirs $file $LIBUNWINDDEP
	echo "	$gcc_compile $flags -fexceptions \$(vis_hide) -c $file -o $out"
	echo $libunwind_a: $out
      fi
    done
  fi

  #
  # build libgcov components
  #
  for name in $LIBGCOV; do
    dir=`echo ${ml} | sed -e 's/;.*$//' -e 's/=/$(EQ)/g'`
    flags=`echo ${ml} | sed -e 's/^[^;]*;//' -e 's/@/ -/g'`;
    out="libgcc/${dir}/${name}${objext}"

    echo $out: $libgcov_c_dep
    echo "	$gcc_compile $flags -DL$name -c \$(srcdir)/libgcov.c -o $out"
    echo $libgcov_a: $out
  done

  # EXTRA_MULTILIB_PARTS.
  if [ -n "$EXTRA_MULTILIB_PARTS" ]; then
    # Each of the EXTRA_MULTILIB_PARTS is built by recursive invocation
    # of the parent Makefile.  We must do this just once for each
    # multilib, passing it all the EXTRA_MULTILIB_PARTS as
    # simultaneous goal targets, so that rules which cannot execute
    # simultaneously are properly serialized.
    
    extra=
    echo
    for f in $EXTRA_MULTILIB_PARTS; do
      case $dir in
      .) out=$f ; t= ;;
      *) out=$dir/$f ; t=$dir/ ;;
      esac
      case $out in
      # Prevent `make' from interpreting $out as a macro assignment
      *'$(EQ)'*) targ="T_TARGET=$out T_TARGET" ;;
      *) targ=$out ;;
      esac
      extra="$extra $targ"
    done

    if [ "$dir" = . ]; then
      suffix=
    else
      suffix=`echo $dir | sed s,/,_,g`
    fi
    echo extra$suffix: stmp-dirs
    echo "	$make_compile" \\
    echo '	  LIBGCC2_CFLAGS="$(LIBGCC2_CFLAGS)' $flags '" ' \\
    echo '	  MULTILIB_CFLAGS="'$flags'"' T=$t $extra
    echo "all: extra$suffix"

    # Make libunwind.so and libgcc_s.so depend on these, since they
    # are likely to be implicitly used by the link process.
    if [ "$libgcc_s_so" ]; then
      echo "$libgcc_s_so: extra$suffix"
    fi
    if [ "$libunwind_so" ]; then
      echo "$libunwind_so: extra$suffix"
    fi
  fi

  # Library build rules.
  dir=`echo ${ml} | sed -e 's/;.*$//' -e 's/=/$(EQ)/g'`
  flags=`echo ${ml} | sed -e 's/^[^;]*;//' -e 's/@/ -/g'`;

  # Map-file generation.
  if [ "$SHLIB_LINK" -a "$SHLIB_MKMAP" ]; then
    mapfile="libgcc/${dir}/libgcc.map"
    tmpmapfile="libgcc/${dir}/tmp-libgcc.map"
    # This uses a here document instead of echos because some shells
    # will convert the \1 in the second sed command to a control-A.
    # The behavior of here documents is more predictable.
    cat <<EOF

${mapfile}: $SHLIB_MKMAP $SHLIB_MAPFILES
	{ \$(NM_FOR_TARGET) $SHLIB_NM_FLAGS \$(objects); echo %%; \\
	  cat $SHLIB_MAPFILES \\
	    | sed -e '/^[   ]*#/d' \\
	          -e 's/^%\(if\|else\|elif\|endif\|define\)/#\1/' \\
	    | $gcc_compile $flags -E -xassembler-with-cpp -; \\
	} | \$(AWK) -f $SHLIB_MKMAP $SHLIB_MKMAP_OPTS > ${tmpmapfile}
	mv '$tmpmapfile' \$@
$libgcc_s_so: ${mapfile}
EOF
  fi

  # Static libraries.

  # Each of these .a files depends on stmp-dirs.  It would seem that
  # this dependency is redundant, since each of the object files
  # itself depends on stmp-dirs.  However, it is possible that there
  # are in fact no object files.  In that case, the stmp-dirs
  # dependency is required; the directory containing the archive must
  # exist before the archive itself can be created.
  echo ""
  echo "$libgcc_a: stmp-dirs"
  echo "	-rm -f $libgcc_a"
  echo '	$(AR_CREATE_FOR_TARGET)' $libgcc_a '$(objects)'
  echo '	$(RANLIB_FOR_TARGET)' $libgcc_a
  echo "all: $libgcc_a"

  echo ""
  echo "$libgcov_a: stmp-dirs"
  echo "	-rm -f $libgcov_a"
  echo '	$(AR_CREATE_FOR_TARGET)' $libgcov_a '$(objects)'
  echo '	$(RANLIB_FOR_TARGET)' $libgcov_a
  echo "all: $libgcov_a"

  # These libraries are not always built.
  if [ "$libunwind_a" ]; then
    echo ""
    echo "$libunwind_a: stmp-dirs"
    echo "	-rm -f $libunwind_a"
    echo '	$(AR_CREATE_FOR_TARGET)' $libunwind_a '$(objects)'
    echo '	$(RANLIB_FOR_TARGET)' $libunwind_a
    echo "all: $libunwind_a"
  fi

  if [ "$libgcc_eh_a" ]; then
    echo ""
    echo "${dir}/libgcc_eh.a: stmp-dirs"
    echo "	-rm -f ${dir}/libgcc_eh.a"
    echo '	$(AR_CREATE_FOR_TARGET)' ${dir}/libgcc_eh.a '$(objects)'
    echo '	$(RANLIB_FOR_TARGET)' ${dir}/libgcc_eh.a
    echo "all: $libgcc_eh_a"
  fi

  # Shared libraries.
  if [ "$libgcc_s_so" ]; then
    echo ""
    echo "$libgcc_s_so: stmp-dirs $libunwind_so"
    echo "	$SHLIB_LINK" \
	 | sed -e "s%@multilib_flags@%$flags%g" \
	       -e "s%@multilib_dir@%$dir%g" \
	       -e "s%@shlib_objs@%\$(objects)%g" \
	       -e "s%@shlib_base_name@%libgcc_s%g" \
	       -e "s%@shlib_map_file@%$mapfile%g" \
	       -e "s%@shlib_slibdir_qual@%$shlib_dir_qual%g"
    echo "all: $libgcc_s_so"
  fi

  if [ "$libunwind_so" ]; then
    echo ""
    echo "$libunwind_so: stmp-dirs"
    echo "	$SHLIBUNWIND_LINK" \
	   | sed -e "s%@multilib_flags@%$flags%g" \
		 -e "s%@multilib_dir@%$dir%g" \
		 -e "s%@shlib_objs@%\$(objects)%g" \
		 -e "s%@shlib_base_name@%libunwind%g" \
		 -e "s%@shlib_slibdir_qual@%$shlib_dir_qual%g"
    echo "all: $libunwind_so"
  fi

done # ml in MULTILIBS

echo
echo "libgcc-stage-start:"
echo "	for dir in \$(dirs); do \\"
echo "	  if [ -d \$(stage)/\$\$dir ]; then :; \\"
echo "	  else $mkinstalldirs \$(stage)/\$\$dir; fi; \\"
echo "	done"
echo "	-for dir in \$(dirs); do \\"
echo "	  mv \$\$dir/*${objext} \$(stage)/\$\$dir; \\"
echo "	  mv \$\$dir/*.vis \$(stage)/\$\$dir; \\"
echo "    mv \$\$dir/*.map \$(stage)/\$\$dir; \\"
echo "	  test ! -f \$\$dir/libgcc.a || mv \$\$dir/lib* \$(stage)/\$\$dir; \\"
echo "	done"

echo 
echo "stmp-dirs:"
echo "	for d in \$(dirs); do \\"
echo "	  if [ -d \$\$d ]; then true; else $mkinstalldirs \$\$d; fi; \\"
echo "	done"
echo "	if [ -f stmp-dirs ]; then true; else touch stmp-dirs; fi"

if [ "$need_eh_dummy" ]; then
  echo "eh_dummy.c:"
  echo "	echo 'int __libgcc_eh_dummy;' > \$@"
fi

echo ""
echo "install: all"
for ml in $MULTILIBS; do
  dir=`echo ${ml} | sed -e 's/;.*$//' -e 's/=/$(EQ)/g'`
  flags=`echo ${ml} | sed -e 's/^[^;]*;//' -e 's/@/ -/g'`;
  if [ $dir != . ]; then
    ldir='$(DESTDIR)$(libsubdir)'/$dir
    echo "	if [ -d $ldir ]; then true; else $mkinstalldirs $ldir; chmod a+rx $ldir; fi;"
  else
    ldir='$(DESTDIR)$(libsubdir)'
  fi
  echo '	$(INSTALL_DATA)' ${dir}/libgcc.a ${ldir}/
  echo '	chmod 644'  ${ldir}/libgcc.a
  echo '	$(RANLIB_FOR_TARGET)' ${ldir}/libgcc.a
  echo '	$(INSTALL_DATA)' ${dir}/libgcov.a ${ldir}/
  echo '	chmod 644'  ${ldir}/libgcov.a
  echo '	$(RANLIB_FOR_TARGET)' ${ldir}/libgcov.a

  if [ "$SHLIB_LINK" ]; then
    echo '	$(INSTALL_DATA)' ${dir}/libgcc_eh.a ${ldir}/
    echo '	chmod 644'  ${ldir}/libgcc_eh.a
    echo '	$(RANLIB_FOR_TARGET)' ${ldir}/libgcc_eh.a

    shlib_slibdir_qual=
    os_multilib_dir=`$GCC_FOR_TARGET $flags --print-multi-os-directory`
    if [ "$os_multilib_dir" != . ]; then
      shlib_slibdir_qual="/$os_multilib_dir"
    fi
    echo "	$SHLIB_INSTALL" \
      | sed -e "s%@multilib_dir@%$dir%g" \
	    -e "s%@shlib_base_name@%libgcc_s%g" \
	    -e "s%@shlib_slibdir_qual@%$shlib_slibdir_qual%g"
    if [ "$LIBUNWIND" ]; then
      echo "	$SHLIBUNWIND_INSTALL" \
	| sed -e "s%@multilib_dir@%$dir%g" \
	      -e "s%@shlib_base_name@%libunwind%g" \
	      -e "s%@shlib_slibdir_qual@%$shlib_slibdir_qual%g"
      libunwinddir='$(DESTDIR)$(slibdir)$(shlib_slibdir_qual)/$(shlib_dir)'
      echo '	$(INSTALL_DATA)' ${dir}/libunwind.a ${libunwinddir}/
      echo '	chmod 644' ${dir}/libunwind.a
      echo '	$(RANLIB_FOR_TARGET)' ${libunwinddir}/libunwind.a
    fi
  fi
done
for f in $EXTRA_MULTILIB_PARTS; do
  for ml in $MULTILIBS; do
    dir=`echo ${ml} | sed -e 's/;.*$//' -e 's/=/$(EQ)/g'`
    if [ $dir != . ]; then
      out=${dir}/$f
      ldir='$(DESTDIR)$(libsubdir)'/$dir
    else
      out=$f
      ldir='$(DESTDIR)$(libsubdir)'
    fi
    echo '	$(INSTALL_DATA)' $out $ldir/
  done
done

echo '.PHONY: all install'