Merge branch 'master' of https://github.com/crosstool-ng/crosstool-ng

7 files changed, 435 insertions, 550 deletions

diff --git a/scripts/build/libc/avr-libc.sh b/scripts/build/libc/avr-libc.sh
index b73f990..3dc91a4 100644
--- a/scripts/build/libc/avr-libc.sh
+++ b/scripts/build/libc/avr-libc.sh
@@ -18,10 +18,6 @@ do_libc_extract() {
     CT_Patch "avr-libc" "${CT_LIBC_VERSION}"
 }
 
-do_libc_check_config() {
-    :
-}
-
 do_libc_configure() {
     CT_DoLog EXTRA "Configuring C library"
 
diff --git a/scripts/build/libc/glibc.sh b/scripts/build/libc/glibc.sh
index 472acad..8027b8f 100644
--- a/scripts/build/libc/glibc.sh
+++ b/scripts/build/libc/glibc.sh
@@ -41,10 +41,6 @@ do_libc_extract() {
     CT_Popd
 }
 
-do_libc_check_config() {
-    :
-}
-
 # Build and install headers and start files
 do_libc_start_files() {
     # Start files and Headers should be configured the same way as the
@@ -68,14 +64,6 @@ do_libc_post_cc() {
 #   libc_mode           : 'startfiles' or 'final'               : string    : (none)
 do_libc_backend() {
     local libc_mode
-    local -a multilibs
-    local multilib
-    local multi_dir
-    local multi_flags
-    local extra_dir
-    local target
-    local libc_headers libc_startfiles libc_full
-    local hdr
     local arg
 
     for arg in "$@"; do
@@ -85,167 +73,77 @@ do_libc_backend() {
     case "${libc_mode}" in
         startfiles)
             CT_DoStep INFO "Installing C library headers & start files"
-            hdr=y
-            libc_startfiles=y
-            libc_full=
             ;;
         final)
             CT_DoStep INFO "Installing C library"
-            hdr=
-            libc_startfiles=
-            libc_full=y
             ;;
-        *)  CT_Abort "Unsupported (or unset) libc_mode='${libc_mode}'";;
+        *)
+            CT_Abort "Unsupported (or unset) libc_mode='${libc_mode}'"
+            ;;
     esac
 
-    # If gcc is not configured for multilib, it still prints
-    # a single line for the default settings
-    multilibs=( $("${CT_TARGET}-gcc" -print-multi-lib 2>/dev/null) )
-    for multilib in "${multilibs[@]}"; do
-        multi_dir="${multilib%%;*}"
-        if [ "${multi_dir}" != "." ]; then
-            CT_DoStep INFO "Building for multilib subdir='${multi_dir}'"
-
-            extra_flags="$( echo "${multilib#*;}"       \
-                            |${sed} -r -e 's/@/ -/g;'   \
-                          )"
-            extra_dir="/${multi_dir}"
-
-            # glibc install its files in ${extra_dir}/{usr/,}lib
-            # while gcc expects them in {,usr/}lib/${extra_dir}.
-            # Prepare some symlinks so glibc installs in fact in
-            # the proper place
-            # We do it in the start-files step, so it is not needed
-            # to do it in the final step, as the symlinks will
-            # already exist
-            if [ "${libc_mode}" = "startfiles" ]; then
-                CT_Pushd "${CT_SYSROOT_DIR}"
-                CT_DoExecLog ALL mkdir -p "lib/${multi_dir}"        \
-                                          "usr/lib/${multi_dir}"    \
-                                          "${multi_dir}"            \
-                                          "${multi_dir}/usr"
-                CT_DoExecLog ALL ln -sf "../lib/${multi_dir}" "${multi_dir}/lib"
-                CT_DoExecLog ALL ln -sf "../../usr/lib/${multi_dir}" "${multi_dir}/usr/lib"
-                CT_Popd
-            fi
-            libc_headers=
-        else
-            extra_dir=
-            extra_flags=
-            libc_headers="${hdr}"
-        fi
-
-        CT_mkdir_pushd "${CT_BUILD_DIR}/build-libc-${libc_mode}${extra_dir//\//_}"
-
-        target=$( CT_DoMultilibTarget "${CT_TARGET}" ${extra_flags} )
-        case "${target}" in
-            # SPARC quirk: glibc 2.23 and newer dropped support for SPARCv8 and
-            # earlier (corresponding pthread barrier code is missing). Until this
-            # support is reintroduced, configure as sparcv9.
-            sparc-*)
-                if [ "${CT_LIBC_GLIBC_2_23_or_later}" = y ]; then
-                    target=${target/#sparc-/sparcv9-}
-                fi
-                ;;
-            # x86 quirk: architecture name is i386, but glibc expects i[4567]86 - to
-            # indicate the desired optimization. If it was a multilib variant of x86_64,
-            # then it targets at least NetBurst a.k.a. i786, but we'll follow arch/x86.sh
-            # and set the optimization to i686. Otherwise, replace with the most
-            # conservative choice, i486.
-            i386-*)
-                if [ "${CT_TARGET_ARCH}" = "x86_64" ]; then
-                    target=${target/#i386-/i686-}
-                else
-                    target=${target/#i386-/i486-}
-                fi
-                ;;
-        esac
-
-        do_libc_backend_once extra_dir="${extra_dir}"               \
-                             extra_flags="${extra_flags}"           \
-                             libc_headers="${libc_headers}"         \
-                             libc_startfiles="${libc_startfiles}"   \
-                             libc_full="${libc_full}"               \
-                             target="${target}"
-
-        CT_Popd
-
-        if [ "${multi_dir}" != "." ]; then
-            if [ "${libc_mode}" = "final" ]; then
-                CT_DoLog EXTRA "Fixing up multilib location"
-
-                # rewrite the library multiplexers
-                for d in "lib/${multi_dir}" "usr/lib/${multi_dir}"; do
-                    for l in libc libpthread libgcc_s; do
-                        if [    -f "${CT_SYSROOT_DIR}/${d}/${l}.so"    \
-                             -a ! -L ${CT_SYSROOT_DIR}/${d}/${l}.so    ]
-                        then
-                            CT_DoExecLog DEBUG ${sed} -r -i                                 \
-                                                      -e "s:/lib/:/lib/${multi_dir}/:g;"    \
-                                                      "${CT_SYSROOT_DIR}/${d}/${l}.so"
-                        fi
-                    done
-                done
-                # Remove the multi_dir now it is no longer useful
-                CT_DoExecLog DEBUG rm -rf "${CT_SYSROOT_DIR}/${multi_dir}"
-            fi # libc_mode == final
-
-            CT_EndStep
-        fi
-    done
-
+    CT_mkdir_pushd "${CT_BUILD_DIR}/build-libc-${libc_mode}"
+    CT_IterateMultilibs do_libc_backend_once multilib libc_mode="${libc_mode}"
+    CT_Popd
     CT_EndStep
 }
 
 # This backend builds the C library once
 # Usage: do_libc_backend_once param=value [...]
-#   Parameter           : Definition                            : Type      : Default
-#   libc_headers        : Build libc headers                    : bool      : n
-#   libc_startfiles     : Build libc start-files                : bool      : n
-#   libc_full           : Build full libc                       : bool      : n
-#   extra_flags         : Extra CFLAGS to use (for multilib)    : string    : (empty)
-#   extra_dir           : Extra subdir for multilib             : string    : (empty)
-#   target              : Build libc using this target (for multilib) : string : ${CT_TARGET}
+#   Parameter           : Definition                            : Type
+#   libc_mode           : 'startfiles' or 'final'               : string    : (empty)
+#   multi_*             : as defined in CT_IterateMultilibs     : (varies)  :
 do_libc_backend_once() {
-    local libc_headers
-    local libc_startfiles
-    local libc_full
-    local extra_flags
-    local extra_dir
+    local multi_flags multi_dir multi_os_dir multi_root multi_index multi_count
+    local startfiles_dir
     local src_dir="${CT_SRC_DIR}/${CT_LIBC}-${CT_LIBC_VERSION}"
-    local extra_cc_args
     local -a extra_config
     local -a extra_make_args
     local glibc_cflags
-    local float_extra
-    local endian_extra
-    local target
-    local arg
+    local arg opt
 
     for arg in "$@"; do
         eval "${arg// /\\ }"
     done
 
-    if [ "${target}" = "" ]; then
-        target="${CT_TARGET}"
+    CT_DoStep INFO "Building for multilib ${multi_index}/${multi_count}: '${multi_flags}'"
+
+    # Ensure sysroot (with suffix, if applicable) exists
+    CT_DoExecLog ALL mkdir -p "${multi_root}"
+
+    # Adjust target tuple according GLIBC quirks
+    CT_DoArchGlibcAdjustTuple multi_target
+
+    # Glibc seems to be smart enough to know about the cases that can coexist
+    # in the same root and installs them into proper multilib-os directory; all
+    # we need is to point to the right root. We do need to handle multilib-os
+    # here, though, for the first pass where we install crt*.o and a dummy
+    # libc.so; we therefore install it to the most specific location of
+    # <sysroot>/<suffix>/usr/lib/<multilib-os> where it is least likely to clash
+    # with other multilib variants. We then remove these temporary files at
+    # the beginning of the libc-final step and allow glibc to install them
+    # where it thinks is proper.
+    startfiles_dir="${multi_root}/usr/lib/${multi_os_dir}"
+    CT_SanitizeVarDir startfiles_dir
+
+    if [ "${libc_mode}" = "final" ]; then
+        CT_DoLog EXTRA "Cleaning up start files"
+        CT_DoExecLog ALL rm -f "${startfiles_dir}/crt1.o" \
+            "${startfiles_dir}/crti.o" \
+            "${startfiles_dir}/crtn.o" \
+            "${startfiles_dir}/libc.so"
     fi
 
     CT_DoLog EXTRA "Configuring C library"
 
-    case "${CT_LIBC}" in
-        glibc)
-            # glibc can't be built without -O2 (reference needed!)
-            OPTIMIZE=-O2
-            # Also, if those two are missing, iconv build breaks
-            extra_config+=( --disable-debug --disable-sanity-checks )
-            ;;
-    esac
+    # Also, if those two are missing, iconv build breaks
+    extra_config+=( --disable-debug --disable-sanity-checks )
 
     # always include rpc, the user can still override it with TI-RPC
     extra_config+=( --enable-obsolete-rpc )
 
     # Add some default glibc config options if not given by user.
-    # We don't need to be conditional on wether the user did set different
+    # We don't need to be conditional on whether the user did set different
     # values, as they CT_LIBC_GLIBC_EXTRA_CONFIG_ARRAY is passed after
     # extra_config
 
@@ -267,21 +165,6 @@ do_libc_backend_once() {
         *) extra_config+=("--disable-shared");;
     esac
 
-    float_extra="$( echo "${extra_flags}"       \
-                    |${sed} -r -e '/^(.*[[:space:]])?-m(hard|soft)-float([[:space:]].*)?$/!d;'  \
-                               -e 's//\2/;'     \
-                  )"
-    case "${float_extra}" in
-        hard)   extra_config+=("--with-fp");;
-        soft)   extra_config+=("--without-fp");;
-        "")
-            case "${CT_ARCH_FLOAT}" in
-                hard|softfp)    extra_config+=("--with-fp");;
-                soft)           extra_config+=("--without-fp");;
-            esac
-            ;;
-    esac
-
     if [ "${CT_LIBC_DISABLE_VERSIONING}" = "y" ]; then
         extra_config+=("--disable-versioning")
     fi
@@ -298,24 +181,6 @@ do_libc_backend_once() {
     extra_config+=("--with-pkgversion=${CT_PKGVERSION}")
     [ -n "${CT_TOOLCHAIN_BUGURL}" ] && extra_config+=("--with-bugurl=${CT_TOOLCHAIN_BUGURL}")
 
-    # Extract the endianness options if any
-    # This should cover all possible endianness options
-    # in gcc, but it is prone to bit-rot... :-(
-    endian_extra="$( echo "${extra_flags}"      \
-                     |${sed} -r -e '/^(.*[[:space:]])?-(E[BL]|m((big|little)(-endian)?|e?[bl]))([[:space:]].*)?$/!d;' \
-                                -e 's//\2/;'    \
-                   )"
-    # If extra_flags contained an endianness option, no need to add it again. Otherwise,
-    # add the option from the configuration.
-    case "${endian_extra}" in
-        EB|mbig-endian|mbig|meb|mb)
-            ;;
-        EL|mlittle-endian|mlittle|mel|ml)
-            ;;
-        "") extra_cc_args="${extra_cc_args} ${CT_ARCH_ENDIAN_OPT}"
-            ;;
-    esac
-
     touch config.cache
     if [ "${CT_LIBC_GLIBC_FORCE_UNWIND}" = "y" ]; then
         echo "libc_cv_forced_unwind=yes" >>config.cache
@@ -325,14 +190,30 @@ do_libc_backend_once() {
     # Pre-seed the configparms file with values from the config option
     printf "%s\n" "${CT_LIBC_GLIBC_CONFIGPARMS}" > configparms
 
-    cross_cc=$(CT_Which "${CT_TARGET}-gcc")
-    extra_cc_args+=" ${extra_flags}"
+    # glibc can't be built without -O2 (reference needed!)
+    glibc_cflags+=" -O2"
 
     case "${CT_LIBC_ENABLE_FORTIFIED_BUILD}" in
         y)  ;;
         *)  glibc_cflags+=" -U_FORTIFY_SOURCE";;
     esac
-    glibc_cflags+=" ${CT_TARGET_CFLAGS} ${OPTIMIZE} ${CT_LIBC_GLIBC_EXTRA_CFLAGS}"
+
+    # In the order of increasing precedence. Flags common to compiler and linker.
+    glibc_cflags+=" ${CT_TARGET_CFLAGS}"
+    glibc_cflags+=" ${CT_LIBC_GLIBC_EXTRA_CFLAGS}"
+    glibc_cflags+=" ${multi_flags}"
+
+    # Analyze the resulting options for any extra configure switches to throw in.
+    for opt in ${glibc_cflags}; do
+        case ${opt} in
+            -mhard-float|-mfloat-abi=hard|-mfloat-abi=softfp|-mno-soft-float|-mfpu)
+                extra_config+=("--with-fp")
+                ;;
+            -msoft-float|-mfloat-abi=soft|-mno-float|-mno-fpu)
+                extra_config+=("--without-fp")
+                ;;
+        esac
+    done
 
     # ./configure is mislead by our tools override wrapper for bash
     # so just tell it where the real bash is _on_the_target_!
@@ -349,31 +230,35 @@ do_libc_backend_once() {
 
     # Configure with --prefix the way we want it on the target...
     # There are a whole lot of settings here.  You'll probably want
-    # to read up on what they all mean, and customize a bit, possibly by setting GLIBC_EXTRA_CONFIG_ARRAY
-    # Compare these options with the ones used when installing the glibc headers above - they're different.
-    # Adding "--without-gd" option to avoid error "memusagestat.c:36:16: gd.h: No such file or directory"
+    # to read up on what they all mean, and customize a bit, possibly
+    # by setting GLIBC_EXTRA_CONFIG_ARRAY.
+    # Compare these options with the ones used when installing
+    # the glibc headers above - they're different.
+    # Adding "--without-gd" option to avoid error "memusagestat.c:36:16:
+    # gd.h: No such file or directory"
     # See also http://sources.redhat.com/ml/libc-alpha/2000-07/msg00024.html.
     # Set BUILD_CC, or we won't be able to build datafiles
     # Run explicitly through CONFIG_SHELL, or the build breaks badly (loop-of-death)
     # when the shell is not bash... Sigh... :-(
 
-    CT_DoLog DEBUG "Using gcc for target    : '${cross_cc}'"
-    CT_DoLog DEBUG "Configuring with addons : '$(do_libc_add_ons_list ,)'"
-    CT_DoLog DEBUG "Extra config args passed: '${extra_config[*]}'"
-    CT_DoLog DEBUG "Extra CC args passed    : '${glibc_cflags}'"
-    CT_DoLog DEBUG "Extra flags (multilib)  : '${extra_flags}'"
+    CT_DoLog DEBUG "Configuring with addons  : '$(do_libc_add_ons_list ,)'"
+    CT_DoLog DEBUG "Extra config args passed : '${extra_config[*]}'"
+    CT_DoLog DEBUG "Extra CFLAGS passed      : '${glibc_cflags}'"
+    CT_DoLog DEBUG "Placing startfiles into  : '${startfiles_dir}'"
+    CT_DoLog DEBUG "Configuring with --host  : '${multi_target}'"
 
+    # CFLAGS are only applied when compiling .c files. .S files are compiled with ASFLAGS,
+    # but they are not passed by configure. Thus, pass everything in CC instead.
     CT_DoExecLog CFG                                                \
-    BUILD_CC="${CT_BUILD}-gcc"                                      \
-    CFLAGS="${glibc_cflags}"                                        \
-    CC="${CT_TARGET}-gcc ${CT_LIBC_EXTRA_CC_ARGS} ${extra_cc_args}" \
+    BUILD_CC=${CT_BUILD}-gcc                                        \
+    CC="${CT_TARGET}-gcc ${glibc_cflags}"                           \
     AR=${CT_TARGET}-ar                                              \
     RANLIB=${CT_TARGET}-ranlib                                      \
     "${CONFIG_SHELL}"                                               \
     "${src_dir}/configure"                                          \
         --prefix=/usr                                               \
         --build=${CT_BUILD}                                         \
-        --host=${target}                                            \
+        --host=${multi_target}                                      \
         --cache-file="$(pwd)/config.cache"                          \
         --without-cvs                                               \
         --disable-profile                                           \
@@ -409,13 +294,14 @@ do_libc_backend_once() {
             ;;
     esac
 
-    if [ "${libc_headers}" = "y" ]; then
+    if [ "${libc_mode}" = "startfiles" -a ! -r "${multi_root}/.libc_headers_installed" ]; then
         CT_DoLog EXTRA "Installing C library headers"
+        CT_DoExecLog ALL touch "${multi_root}/.libc_headers_installed"
 
         # use the 'install-headers' makefile target to install the
         # headers
         CT_DoExecLog ALL ${make} ${JOBSFLAGS}                       \
-                         install_root=${CT_SYSROOT_DIR}${extra_dir} \
+                         install_root=${multi_root}                 \
                          install-bootstrap-headers=yes              \
                          "${extra_make_args[@]}"                    \
                          install-headers
@@ -456,47 +342,52 @@ do_libc_backend_once() {
                     ;;
             esac
         fi
-    fi # libc_headers == y
+    elif [ "${libc_mode}" = "final" -a -r "${multi_root}/.libc_headers_installed" ]; then
+        CT_DoExecLog ALL rm -f "${multi_root}/.libc_headers_installed"
+    fi # installing headers
 
-    if [ "${libc_startfiles}" = "y" ]; then
+    if [ "${libc_mode}" = "startfiles" ]; then
         if [ "${CT_THREADS}" = "nptl" ]; then
             CT_DoLog EXTRA "Installing C library start files"
 
             # there are a few object files needed to link shared libraries,
             # which we build and install by hand
-            CT_DoExecLog ALL mkdir -p "${CT_SYSROOT_DIR}${extra_dir}/usr/lib"
+            CT_DoExecLog ALL mkdir -p "${startfiles_dir}"
             CT_DoExecLog ALL ${make} ${JOBSFLAGS} \
-                        "${extra_make_args[@]}"   \
+                        "${extra_make_args[@]}" \
                         csu/subdir_lib
             CT_DoExecLog ALL cp csu/crt1.o csu/crti.o csu/crtn.o    \
-                                "${CT_SYSROOT_DIR}${extra_dir}/usr/lib"
+                                "${startfiles_dir}"
 
             # Finally, 'libgcc_s.so' requires a 'libc.so' to link against.
             # However, since we will never actually execute its code,
             # it doesn't matter what it contains.  So, treating '/dev/null'
             # as a C source file, we produce a dummy 'libc.so' in one step
-            CT_DoExecLog ALL "${cross_cc}" ${extra_flags}   \
-                                           -nostdlib        \
-                                           -nostartfiles    \
-                                           -shared          \
-                                           -x c /dev/null   \
-                                           -o "${CT_SYSROOT_DIR}${extra_dir}/usr/lib/libc.so"
+            CT_DoExecLog ALL "${CT_TARGET}-gcc" ${multi_flags}   \
+                                           -nostdlib             \
+                                           -nostartfiles         \
+                                           -shared               \
+                                           -x c /dev/null        \
+                                           -o "${startfiles_dir}/libc.so"
         fi # threads == nptl
-    fi # libc_headers == y
+    fi # libc_mode = startfiles
 
-    if [ "${libc_full}" = "y" ]; then
+    if [ "${libc_mode}" = "final" ]; then
         CT_DoLog EXTRA "Building C library"
         CT_DoExecLog ALL ${make} ${JOBSFLAGS}         \
                               "${extra_make_args[@]}" \
                               all
 
         CT_DoLog EXTRA "Installing C library"
-        CT_DoExecLog ALL ${make} ${JOBSFLAGS}                               \
-                              "${extra_make_args[@]}"                       \
-                              install_root="${CT_SYSROOT_DIR}${extra_dir}"  \
+        CT_DoExecLog ALL ${make} ${JOBSFLAGS}                 \
+                              "${extra_make_args[@]}"         \
+                              install_root="${multi_root}"    \
                               install
 
-        if [ "${CT_BUILD_MANUALS}" = "y" ]; then
+        if [ "${CT_BUILD_MANUALS}" = "y" -a "${multi_index}" = "${multi_count}" ]; then
+            # We only need to build the manuals once. Only build them on the
+            # last multilib target. If it's not multilib, it will happen on the
+            # only target.
             CT_DoLog EXTRA "Building and installing the C library manual"
             # Omit JOBSFLAGS as GLIBC has problems building the
             # manuals in parallel
@@ -507,10 +398,12 @@ do_libc_backend_once() {
                                     ${CT_PREFIX_DIR}/share/doc
         fi
 
-        if [ "${CT_LIBC_LOCALES}" = "y" ]; then
+        if [ "${CT_LIBC_LOCALES}" = "y" -a "${multi_index}" = "${multi_count}" ]; then
             do_libc_locales
         fi
-    fi # libc_full == y
+    fi # libc_mode = final
+
+    CT_EndStep
 }
 
 # Build up the addons list, separated with $1
diff --git a/scripts/build/libc/mingw.sh b/scripts/build/libc/mingw.sh
index a22c2ba..e2b781d 100644
--- a/scripts/build/libc/mingw.sh
+++ b/scripts/build/libc/mingw.sh
@@ -23,10 +23,6 @@ do_libc_extract() {
     CT_Popd
 }
 
-do_libc_check_config() {
-    :
-}
-
 do_set_mingw_install_prefix(){
     MINGW_INSTALL_PREFIX=/usr/${CT_TARGET}
     if [[ ${CT_WINAPI_VERSION} == 2* ]]; then
diff --git a/scripts/build/libc/musl.sh b/scripts/build/libc/musl.sh
index 2699d79..2a0c04f 100644
--- a/scripts/build/libc/musl.sh
+++ b/scripts/build/libc/musl.sh
@@ -16,10 +16,6 @@ do_libc_extract() {
     CT_Patch "musl" "${CT_LIBC_VERSION}"
 }
 
-do_libc_check_config() {
-    :
-}
-
 # Build and install headers and start files
 do_libc_start_files() {
     # Start files and Headers should be configured the same way as the
@@ -36,36 +32,51 @@ do_libc_post_cc() {
     :
 }
 
+do_libc_backend() {
+    local libc_mode
+    local arg
+
+    for arg in "$@"; do
+        eval "${arg// /\\ }"
+    done
+
+    case "${libc_mode}" in
+        startfiles)     CT_DoStep INFO "Installing C library headers & start files";;
+        final)          CT_DoStep INFO "Installing C library";;
+        *)              CT_Abort "Unsupported (or unset) libc_mode='${libc_mode}'";;
+    esac
+
+    CT_mkdir_pushd "${CT_BUILD_DIR}/build-libc-${libc_mode}"
+    CT_IterateMultilibs do_libc_backend_once multilib libc_mode="${libc_mode}"
+    CT_Popd
+    CT_EndStep
+}
+
 # This backend builds the C library
 # Usage: do_libc_backend param=value [...]
 #   Parameter           : Definition                      : Type      : Default
 #   libc_mode           : 'startfiles' or 'final'         : string    : (none)
-do_libc_backend() {
+do_libc_backend_once() {
     local libc_mode
     local -a extra_cflags
     local -a extra_config
     local src_dir="${CT_SRC_DIR}/${CT_LIBC}-${CT_LIBC_VERSION}"
-    local libc_headers libc_startfiles libc_full
+    local multi_dir multi_os_dir multi_root multi_flags multi_index multi_count
+    local multilib_dir
+    local hdr_install_subdir
+    local arg f l
 
     for arg in "$@"; do
         eval "${arg// /\\ }"
     done
 
-    case "${libc_mode}" in
-        startfiles)
-            CT_DoStep INFO "Installing C library headers & start files"
-            libc_headers=y
-            libc_startfiles=y
-            libc_full=
-            ;;
-        final)
-            CT_DoStep INFO "Installing C library"
-            libc_headers=
-            libc_startfiles=
-            libc_full=y
-            ;;
-        *)  CT_Abort "Unsupported (or unset) libc_mode='${libc_mode}'";;
-    esac
+    CT_DoStep INFO "Building for multilib ${multi_index}/${multi_count}: '${multi_flags}'"
+
+    multilib_dir="/usr/lib/${multi_os_dir}"
+    CT_SanitizeVarDir multilib_dir
+    CT_DoExecLog ALL mkdir -p "${multi_root}${multilib_dir}"
+
+    extra_cflags=( ${multi_flags} )
 
     # From buildroot:
     # gcc constant folding bug with weak aliases workaround
@@ -84,42 +95,64 @@ do_libc_backend() {
 
     extra_config+=( "--enable-optimize=${CT_LIBC_MUSL_OPTIMIZE}" )
 
-    CT_mkdir_pushd "${CT_BUILD_DIR}/build-libc-${libc_mode}"
+    # Same problem as with uClibc: different variants sometimes have
+    # incompatible headers.
+    CT_DoArchMUSLHeaderDir hdr_install_subdir "${multi_flags}"
+    if [ -n "${hdr_install_subdir}" ]; then
+        extra_config+=( "--includedir=/usr/include/${hdr_install_subdir}" )
+    fi
 
     # NOTE: musl handles the build/host/target a little bit differently
     # then one would expect:
     #   build   : not used
-    #   host    : the machine building musl
+    #   host    : same as --target
     #   target  : the machine musl runs on
-    CT_DoExecLog CFG                \
-    CFLAGS="${extra_cflags[@]}"     \
-    CROSS_COMPILE="${CT_TARGET}-"   \
-    ${src_dir}/configure            \
-        --host="${CT_TARGET}"       \
-        --target="${CT_TARGET}"     \
-        --prefix="/usr"             \
-        --disable-gcc-wrapper       \
+    CT_DoExecLog CFG                                      \
+    CFLAGS="${extra_cflags[*]}"                           \
+    CROSS_COMPILE="${CT_TARGET}-"                         \
+    ${src_dir}/configure                                  \
+        --host="${multi_target}"                          \
+        --target="${multi_target}"                        \
+        --prefix="/usr"                                   \
+        --libdir="${multilib_dir}"                        \
+        --disable-gcc-wrapper                             \
         "${extra_config[@]}"
 
-    if [ "${libc_headers}" = "y" ]; then
+    if [ "${libc_mode}" = "startfiles" ]; then
         CT_DoLog EXTRA "Installing C library headers"
-        CT_DoExecLog ALL ${make} DESTDIR="${CT_SYSROOT_DIR}" install-headers
-    fi
-    if [ "${libc_startfiles}" = "y" ]; then
+        CT_DoExecLog ALL ${make} DESTDIR="${multi_root}" install-headers
         CT_DoLog EXTRA "Building C library start files"
-        CT_DoExecLog ALL ${make} DESTDIR="${CT_SYSROOT_DIR}" \
+        CT_DoExecLog ALL ${make} DESTDIR="${multi_root}" \
             obj/crt/crt1.o obj/crt/crti.o obj/crt/crtn.o
         CT_DoLog EXTRA "Installing C library start files"
-        CT_DoExecLog ALL cp -av obj/crt/crt*.o "${CT_SYSROOT_DIR}/usr/lib"
+        CT_DoExecLog ALL cp -av obj/crt/crt*.o "${multi_root}${multilib_dir}"
         CT_DoExecLog ALL ${CT_TARGET}-gcc -nostdlib \
-            -nostartfiles -shared -x c /dev/null -o "${CT_SYSROOT_DIR}/usr/lib/libc.so"
+            -nostartfiles -shared -x c /dev/null -o "${multi_root}${multilib_dir}/libc.so"
     fi
-    if [ "${libc_full}" = "y" ]; then
+    if [ "${libc_mode}" = "final" ]; then
+        CT_DoLog EXTRA "Cleaning up start files"
+        CT_DoExecLog ALL rm -f "${multi_root}${multilib_dir}/crt1.o" \
+            "${multi_root}${multilib_dir}/crti.o" \
+            "${multi_root}${multilib_dir}/crtn.o" \
+            "${multi_root}${multilib_dir}/libc.so"
+
         CT_DoLog EXTRA "Building C library"
         CT_DoExecLog ALL ${make} ${JOBSFLAGS}
 
         CT_DoLog EXTRA "Installing C library"
-        CT_DoExecLog ALL ${make} DESTDIR="${CT_SYSROOT_DIR}" install
+        CT_DoExecLog ALL ${make} DESTDIR="${multi_root}" install
+
+        # Convert /lib/ld-* symlinks to relative paths so that they are valid
+        # both on the host and on the target.
+        for f in ${multi_root}/ld-musl-*; do
+            [ -L "${f}" ] || continue
+            l=$( readlink ${f} )
+            case "${l}" in
+                ${multilib_dir}/*)
+                    CT_DoExecLog ALL ln -sf "../${l}" "${f}"
+                    ;;
+            esac
+        done
     fi
 
     CT_EndStep
diff --git a/scripts/build/libc/newlib.sh b/scripts/build/libc/newlib.sh
index e70b669..d9bda06 100644
--- a/scripts/build/libc/newlib.sh
+++ b/scripts/build/libc/newlib.sh
@@ -38,10 +38,6 @@ do_libc_extract() {
     fi
 }
 
-do_libc_check_config() {
-    :
-}
-
 do_libc_start_files() {
     CT_DoStep INFO "Installing C library headers & start files"
     CT_DoExecLog ALL cp -a "${CT_SRC_DIR}/newlib-${CT_LIBC_VERSION}/newlib/libc/include/." \
diff --git a/scripts/build/libc/none.sh b/scripts/build/libc/none.sh
index d4bf7dc..8537a8e 100644
--- a/scripts/build/libc/none.sh
+++ b/scripts/build/libc/none.sh
@@ -10,10 +10,6 @@ do_libc_extract() {
     :
 }
 
-do_libc_check_config() {
-    :
-}
-
 do_libc_start_files() {
     :
 }
diff --git a/scripts/build/libc/uClibc.sh b/scripts/build/libc/uClibc.sh
index 422412c..47e135b 100644
--- a/scripts/build/libc/uClibc.sh
+++ b/scripts/build/libc/uClibc.sh
@@ -5,7 +5,7 @@
 # This is a constant because it does not change very often.
 # We're in 2010, and are still using data from 7 years ago.
 uclibc_locales_version=030818
-uclibc_local_tarball="uClibc-locale-${uclibc_locales_version}"
+uclibc_locale_tarball="uClibc-locale-${uclibc_locales_version}"
 
 if [ "${CT_LIBC_UCLIBC_NG}" = "y" ]; then
     uclibc_name="uClibc-ng"
@@ -26,7 +26,7 @@ do_libc_get() {
     fi
     # uClibc locales
     if [ "${CT_LIBC_UCLIBC_LOCALES_PREGEN_DATA}" = "y" ]; then
-        CT_GetFile "${uclibc_local_tarball}" ${libc_src}
+        CT_GetFile "${uclibc_locale_tarball}" ${libc_src}
     fi
 
     return 0
@@ -41,196 +41,207 @@ do_libc_extract() {
     # Extracting pregen locales ourselves is kinda
     # broken, so just link it in place...
     if [    "${CT_LIBC_UCLIBC_LOCALES_PREGEN_DATA}" = "y"           \
-         -a ! -f "${CT_SRC_DIR}/.${uclibc_local_tarball}.extracted" ]; then
+         -a ! -f "${CT_SRC_DIR}/.${uclibc_locale_tarball}.extracted" ]; then
         CT_Pushd "${CT_SRC_DIR}/${uclibc_name}-${CT_LIBC_VERSION}/extra/locale"
-        CT_DoExecLog ALL ln -s "${CT_TARBALLS_DIR}/${uclibc_local_tarball}.tgz" .
+        CT_DoExecLog ALL ln -s "${CT_TARBALLS_DIR}/${uclibc_locale_tarball}.tgz" .
         CT_Popd
-        touch "${CT_SRC_DIR}/.${uclibc_local_tarball}.extracted"
+        touch "${CT_SRC_DIR}/.${uclibc_locale_tarball}.extracted"
     fi
 
     return 0
 }
 
-# Check that uClibc has been previously configured
-do_libc_check_config() {
-    CT_DoStep INFO "Checking C library configuration"
+# Build and install headers and start files
+do_libc_start_files() {
+    # Start files and Headers should be configured the same way as the
+    # final libc, but built and installed differently.
+    do_libc_backend libc_mode=startfiles
+}
 
-    # Use the default config if the user did not provide one.
-    if [ -z "${CT_LIBC_UCLIBC_CONFIG_FILE}" ]; then
-        CT_LIBC_UCLIBC_CONFIG_FILE="${CT_LIB_DIR}/contrib/uClibc-defconfigs/${uclibc_name}.config"
-    fi
+# This function builds and install the full C library
+do_libc() {
+    do_libc_backend libc_mode=final
+}
 
-    if ${grep} -E '^KERNEL_SOURCE=' "${CT_LIBC_UCLIBC_CONFIG_FILE}" >/dev/null 2>&1; then
-        CT_DoLog WARN "Your uClibc version refers to the kernel _sources_, which is bad."
-        CT_DoLog WARN "I can't guarantee that our little hack will work. Please try to upgrade."
-    fi
+# Common backend for 1st and 2nd passes.
+do_libc_backend() {
+    local libc_mode
+    local arg
+
+    for arg in "$@"; do
+        eval "${arg// /\\ }"
+    done
+
+    case "${libc_mode}" in
+        startfiles)     CT_DoStep INFO "Installing C library headers & start files";;
+        final)          CT_DoStep INFO "Installing C library";;
+        *)              CT_Abort "Unsupported (or unset) libc_mode='${libc_mode}'";;
+    esac
 
-    CT_DoLog EXTRA "Manage uClibc configuration"
-    manage_uClibc_config "${CT_LIBC_UCLIBC_CONFIG_FILE}" "${CT_CONFIG_DIR}/uClibc.config"
+    CT_mkdir_pushd "${CT_BUILD_DIR}/build-libc-${libc_mode}"
+    CT_IterateMultilibs do_libc_backend_once multilib libc_mode="${libc_mode}"
 
+
+    CT_Popd
     CT_EndStep
 }
 
-# Build and install headers and start files
-do_libc_start_files() {
-    local cross
+# Common backend for 1st and 2nd passes, once per multilib.
+do_libc_backend_once() {
+    local libc_mode
+    local multi_dir multi_os_dir multi_root multi_flags multi_index multi_count
+    local multilib_dir startfiles_dir
+    local jflag=${CT_LIBC_UCLIBC_PARALLEL:+${JOBSFLAGS}}
+    local -a make_args
+    local extra_cflags f cfg_cflags cf
+    local hdr_install_subdir
+
+    for arg in "$@"; do
+        eval "${arg// /\\ }"
+    done
 
-    CT_DoStep INFO "Installing C library headers"
+    CT_DoStep INFO "Building for multilib ${multi_index}/${multi_count}: '${multi_flags}'"
 
     # Simply copy files until uClibc has the ability to build out-of-tree
     CT_DoLog EXTRA "Copying sources to build dir"
-    CT_DoExecLog ALL cp -av "${CT_SRC_DIR}/${uclibc_name}-${CT_LIBC_VERSION}"   \
-                            "${CT_BUILD_DIR}/build-libc-headers"
-    cd "${CT_BUILD_DIR}/build-libc-headers"
-
-    # Retrieve the config file
-    CT_DoExecLog ALL cp "${CT_CONFIG_DIR}/uClibc.config" .config
-
-    # uClibc uses the CROSS environment variable as a prefix to the
-    # compiler tools to use.  Setting it to the empty string forces
-    # use of the native build host tools, which we need at this
-    # stage, as we don't have target tools yet.
-    # BUT! With NPTL, we need a cross-compiler (and we have it)
-    if [ "${CT_THREADS}" = "nptl" ]; then
-        cross="${CT_TARGET}-"
-    fi
+    CT_DoExecLog ALL cp -aT "${CT_SRC_DIR}/${uclibc_name}-${CT_LIBC_VERSION}" .
+
+    multilib_dir="lib/${multi_os_dir}"
+    startfiles_dir="${multi_root}/usr/${multilib_dir}"
+    CT_SanitizeVarDir multilib_dir startfiles_dir
+
+    # Construct make arguments:
+    # - uClibc uses the CROSS environment variable as a prefix to the compiler
+    #   tools to use.  Since it requires core pass-1, thusly named compiler is
+    #   already available.
+    # - Note about CFLAGS: In uClibc, CFLAGS are generated by Rules.mak,
+    #   depending  on the configuration of the library. That is, they are tailored
+    #   to best fit the target. So it is useless and seems to be a bad thing to
+    #   use LIBC_EXTRA_CFLAGS here.
+    # - We do _not_ want to strip anything for now, in case we specifically
+    #   asked for a debug toolchain, thus the STRIPTOOL= assignment.
+    make_args=( CROSS_COMPILE="${CT_TARGET}-"                           \
+                PREFIX="${multi_root}/"                                 \
+                MULTILIB_DIR="${multilib_dir}"                          \
+                LOCALE_DATA_FILENAME="${uclibc_locale_tarball}.tgz"     \
+                STRIPTOOL=true                                          \
+                ${CT_LIBC_UCLIBC_VERBOSITY}                             \
+                )
 
     # Force the date of the pregen locale data, as the
     # newer ones that are referenced are not available
     CT_DoLog EXTRA "Applying configuration"
-    CT_DoYes "" |CT_DoExecLog ALL                                   \
-                 ${make} CROSS_COMPILE="${cross}"                   \
-                 UCLIBC_EXTRA_CFLAGS="-pipe"                        \
-                 PREFIX="${CT_SYSROOT_DIR}/"                        \
-                 LOCALE_DATA_FILENAME="${uclibc_local_tarball}.tgz" \
-                 oldconfig
-
-    CT_DoLog EXTRA "Building headers"
-    CT_DoExecLog ALL                                        \
-    ${make} ${CT_LIBC_UCLIBC_VERBOSITY}                     \
-         CROSS_COMPILE="${cross}"                           \
-         UCLIBC_EXTRA_CFLAGS="-pipe"                        \
-         PREFIX="${CT_SYSROOT_DIR}/"                        \
-         LOCALE_DATA_FILENAME="${uclibc_local_tarball}.tgz" \
-         headers
-
-    CT_DoLog EXTRA "Installing headers"
-    CT_DoExecLog ALL                                        \
-    ${make} ${CT_LIBC_UCLIBC_VERBOSITY}                     \
-         CROSS_COMPILE="${cross}"                           \
-         UCLIBC_EXTRA_CFLAGS="-pipe"                        \
-         PREFIX="${CT_SYSROOT_DIR}/"                        \
-         LOCALE_DATA_FILENAME="${uclibc_local_tarball}.tgz" \
-         install_headers
-
-    if [ "${CT_THREADS}" = "nptl" ]; then
-        CT_DoLog EXTRA "Building start files"
-        CT_DoExecLog ALL                                        \
-        ${make} ${CT_LIBC_UCLIBC_PARALLEL:+${JOBSFLAGS}}        \
-             CROSS_COMPILE="${cross}"                           \
-             UCLIBC_EXTRA_CFLAGS="-pipe"                        \
-             PREFIX="${CT_SYSROOT_DIR}/"                        \
-             STRIPTOOL=true                                     \
-             ${CT_LIBC_UCLIBC_VERBOSITY}                        \
-             LOCALE_DATA_FILENAME="${uclibc_local_tarball}.tgz" \
-             lib/crt1.o lib/crti.o lib/crtn.o
-
-        # From:  http://git.openembedded.org/cgit.cgi/openembedded/commit/?id=ad5668a7ac7e0436db92e55caaf3fdf782b6ba3b
-        # libm.so is needed for ppc, as libgcc is linked against libm.so
-        # No problem to create it for other archs.
-        CT_DoLog EXTRA "Building dummy shared libs"
-        CT_DoExecLog ALL "${cross}gcc" -nostdlib        \
-                                       -nostartfiles    \
-                                       -shared          \
-                                       -x c /dev/null   \
-                                       -o libdummy.so
-
-        CT_DoLog EXTRA "Installing start files"
-        CT_DoExecLog ALL ${install} -m 0644 lib/crt1.o lib/crti.o lib/crtn.o   \
-                                         "${CT_SYSROOT_DIR}/usr/lib"
-
-        CT_DoLog EXTRA "Installing dummy shared libs"
-        CT_DoExecLog ALL ${install} -m 0755 libdummy.so "${CT_SYSROOT_DIR}/usr/lib/libc.so"
-        CT_DoExecLog ALL ${install} -m 0755 libdummy.so "${CT_SYSROOT_DIR}/usr/lib/libm.so"
-    fi # CT_THREADS == nptl
 
-    CT_EndStep
-}
+    # Use the default config if the user did not provide one.
+    if [ -z "${CT_LIBC_UCLIBC_CONFIG_FILE}" ]; then
+        CT_LIBC_UCLIBC_CONFIG_FILE="${CT_LIB_DIR}/contrib/uClibc-defconfigs/${uclibc_name}.config"
+    fi
 
-# This function build and install the full uClibc
-do_libc() {
-    CT_DoStep INFO "Installing C library"
+    manage_uClibc_config "${CT_LIBC_UCLIBC_CONFIG_FILE}" .config "${multi_flags}"
+    CT_DoYes | CT_DoExecLog ALL ${make} "${make_args[@]}" oldconfig
+
+    # Now filter the multilib flags. manage_uClibc_config did the opposite of
+    # what Rules.mak in uClibc would do: by the multilib's CFLAGS, it determined
+    # the applicable configuration options. We don't want to pass the same options
+    # in the UCLIBC_EXTRA_CFLAGS again (on some targets, the options do not correctly
+    # override each other). On the other hand, we do not want to lose the options
+    # that are not reflected in the .config.
+    extra_cflags="-pipe"
+    { echo "include Rules.mak"; echo "show-cpu-flags:"; printf '\t@echo $(CPU_CFLAGS)\n'; } \
+                > .show-cpu-cflags.mk
+    cfg_cflags=$( ${make} "${make_args[@]}" \
+        --no-print-directory -f .show-cpu-cflags.mk show-cpu-flags )
+    CT_DoExecLog ALL rm -f .show-cpu-cflags.mk
+    CT_DoLog DEBUG "CPU_CFLAGS detected by uClibc: ${cfg_cflags[@]}"
+    for f in ${multi_flags}; do
+        for cf in ${cfg_cflags}; do
+            if [ "${f}" = "${cf}" ]; then
+                f=
+                break
+            fi
+        done
+        if [ -n "${f}" ]; then
+            extra_cflags+=" ${f}"
+        fi
+    done
+    CT_DoLog DEBUG "Filtered multilib CFLAGS: ${extra_cflags}"
+    make_args+=( UCLIBC_EXTRA_CFLAGS="${extra_cflags}" )
+
+    # uClibc does not have a way to select the installation subdirectory for headers,
+    # it is always $(DEVEL_PREFIX)/include. Also, we're reinstalling the headers
+    # at the final stage (see the note below), we may already have the subdirectory
+    # in /usr/include.
+    CT_DoArchUClibcHeaderDir hdr_install_subdir "${multi_flags}"
+    if [ -n "${hdr_install_subdir}" ]; then
+        CT_DoExecLog ALL cp -a "${multi_root}/usr/include" "${multi_root}/usr/include.saved"
+    fi
 
-    # Simply copy files until uClibc has the ability to build out-of-tree
-    CT_DoLog EXTRA "Copying sources to build dir"
-    CT_DoExecLog ALL cp -av "${CT_SRC_DIR}/${uclibc_name}-${CT_LIBC_VERSION}"   \
-                            "${CT_BUILD_DIR}/build-libc"
-    cd "${CT_BUILD_DIR}/build-libc"
-
-    # Retrieve the config file
-    CT_DoExecLog ALL cp "${CT_CONFIG_DIR}/uClibc.config" .config
-
-    # uClibc uses the CROSS environment variable as a prefix to the compiler
-    # tools to use.  The newly built tools should be in our path, so we need
-    # only give the correct name for them.
-    # Note about CFLAGS: In uClibc, CFLAGS are generated by Rules.mak,
-    # depending  on the configuration of the library. That is, they are tailored
-    # to best fit the target. So it is useless and seems to be a bad thing to
-    # use LIBC_EXTRA_CFLAGS here.
-    CT_DoLog EXTRA "Applying configuration"
-    CT_DoYes "" |CT_DoExecLog CFG                                   \
-                 ${make} CROSS_COMPILE=${CT_TARGET}-                \
-                 UCLIBC_EXTRA_CFLAGS="-pipe"                        \
-                 PREFIX="${CT_SYSROOT_DIR}/"                        \
-                 LOCALE_DATA_FILENAME="${uclibc_local_tarball}.tgz" \
-                 oldconfig
-
-    # We do _not_ want to strip anything for now, in case we specifically
-    # asked for a debug toolchain, thus the STRIPTOOL= assignment
-    # /Old/ versions can not build in //
-    CT_DoLog EXTRA "Building C library"
-    CT_DoExecLog ALL                                        \
-    ${make} -j1                                             \
-         CROSS_COMPILE=${CT_TARGET}-                        \
-         UCLIBC_EXTRA_CFLAGS="-pipe"                        \
-         PREFIX="${CT_SYSROOT_DIR}/"                        \
-         STRIPTOOL=true                                     \
-         ${CT_LIBC_UCLIBC_VERBOSITY}                        \
-         LOCALE_DATA_FILENAME="${uclibc_local_tarball}.tgz" \
-         pregen
-    CT_DoExecLog ALL                                        \
-    ${make} ${CT_LIBC_UCLIBC_PARALLEL:+${JOBSFLAGS}}        \
-         CROSS_COMPILE=${CT_TARGET}-                        \
-         UCLIBC_EXTRA_CFLAGS="-pipe"                        \
-         PREFIX="${CT_SYSROOT_DIR}/"                        \
-         STRIPTOOL=true                                     \
-         ${CT_LIBC_UCLIBC_VERBOSITY}                        \
-         LOCALE_DATA_FILENAME="${uclibc_local_tarball}.tgz" \
-         all
-
-    # YEM-FIXME:
-    # - we want to install 'runtime' files, eg. lib*.{a,so*}, crti.o and
-    #   such files, except the headers as they already are installed
-    # - "make install_dev" installs the headers, the crti.o... and the
-    #   static libs, but not the dynamic libs
-    # - "make install_runtime" installs the dynamic libs only
-    # - "make install" calls install_runtime and install_dev
-    # - so we're left with re-installing the headers... Sigh...
-    #
-    # We do _not_ want to strip anything for now, in case we specifically
-    # asked for a debug toolchain, hence the STRIPTOOL= assignment
-    #
-    # Note: JOBSFLAGS is not usefull for installation.
-    #
-    CT_DoLog EXTRA "Installing C library"
-    CT_DoExecLog ALL                                        \
-    ${make} CROSS_COMPILE=${CT_TARGET}-                     \
-         UCLIBC_EXTRA_CFLAGS="-pipe"                        \
-         PREFIX="${CT_SYSROOT_DIR}/"                        \
-         STRIPTOOL=true                                     \
-         ${CT_LIBC_UCLIBC_VERBOSITY}                        \
-         LOCALE_DATA_FILENAME="${uclibc_local_tarball}.tgz" \
-         install
+    if [ "${libc_mode}" = "startfiles" ]; then
+        CT_DoLog EXTRA "Building headers"
+        CT_DoExecLog ALL ${make} "${make_args[@]}" headers
+
+        # Ensure the directory for installing multilib-specific binaries exists.
+        CT_DoExecLog ALL mkdir -p "${startfiles_dir}"
+
+        CT_DoLog EXTRA "Installing headers"
+        CT_DoExecLog ALL ${make} "${make_args[@]}" install_headers
+
+        # The check might look bogus, but it is the same condition as is used
+        # by GCC build script to enable/disable shared library support.
+        if [ "${CT_THREADS}" = "nptl" ]; then
+            CT_DoLog EXTRA "Building start files"
+            CT_DoExecLog ALL ${make} ${jflag} "${make_args[@]}" \
+                lib/crt1.o lib/crti.o lib/crtn.o
+
+            # From:  http://git.openembedded.org/cgit.cgi/openembedded/commit/?id=ad5668a7ac7e0436db92e55caaf3fdf782b6ba3b
+            # libm.so is needed for ppc, as libgcc is linked against libm.so
+            # No problem to create it for other archs.
+            CT_DoLog EXTRA "Building dummy shared libs"
+            CT_DoExecLog ALL "${CT_TARGET}-gcc" -nostdlib -nostartfiles \
+                -shared ${multi_flags} -x c /dev/null -o libdummy.so
+
+            CT_DoLog EXTRA "Installing start files"
+            CT_DoExecLog ALL ${install} -m 0644 lib/crt1.o lib/crti.o lib/crtn.o \
+                                             "${startfiles_dir}"
+
+            CT_DoLog EXTRA "Installing dummy shared libs"
+            CT_DoExecLog ALL ${install} -m 0755 libdummy.so "${startfiles_dir}/libc.so"
+            CT_DoExecLog ALL ${install} -m 0755 libdummy.so "${startfiles_dir}/libm.so"
+        fi # CT_THREADS == nptl
+    fi # libc_mode == startfiles
+
+    if [ "${libc_mode}" = "final" ]; then
+        CT_DoLog EXTRA "Cleaning up startfiles"
+        CT_DoExecLog ALL rm -f "${startfiles_dir}/crt1.o" \
+                    "${startfiles_dir}/crti.o" \
+                    "${startfiles_dir}/crtn.o" \
+                    "${startfiles_dir}/libc.so" \
+                    "${startfiles_dir}/libm.so"
+
+        CT_DoLog EXTRA "Building C library"
+        CT_DoExecLog ALL ${make} "${make_args[@]}" pregen
+        CT_DoExecLog ALL ${make} ${jflag} "${make_args[@]}" all
+
+        # YEM-FIXME:
+        # - we want to install 'runtime' files, eg. lib*.{a,so*}, crti.o and
+        #   such files, except the headers as they already are installed
+        # - "make install_dev" installs the headers, the crti.o... and the
+        #   static libs, but not the dynamic libs
+        # - "make install_runtime" installs the dynamic libs only
+        # - "make install" calls install_runtime and install_dev
+        # - so we're left with re-installing the headers... Sigh...
+        CT_DoLog EXTRA "Installing C library"
+        CT_DoExecLog ALL ${make} "${make_args[@]}" install install_utils
+    fi # libc_mode == final
+
+    # Now, if installing headers into a subdirectory, put everything in its place.
+    # Remove the header subdirectory if it existed already.
+    if [ -n "${hdr_install_subdir}" ]; then
+        CT_DoExecLog ALL mv "${multi_root}/usr/include" "${multi_root}/usr/include.new"
+        CT_DoExecLog ALL mv "${multi_root}/usr/include.saved" "${multi_root}/usr/include"
+        CT_DoExecLog ALL rm -rf "${multi_root}/usr/include/${hdr_install_subdir}"
+        CT_DoExecLog ALL mv "${multi_root}/usr/include.new" "${multi_root}/usr/include/${hdr_install_subdir}"
+    fi
 
     CT_EndStep
 }
@@ -241,98 +252,11 @@ do_libc() {
 manage_uClibc_config() {
     src="$1"
     dst="$2"
+    flags="$3"
 
     # Start with fresh files
-    CT_DoExecLog ALL rm -f "${dst}"
-    CT_DoExecLog ALL mkdir -p "$(dirname ${dst})"
     CT_DoExecLog ALL cp "${src}" "${dst}"
 
-    # Hack our target in the config file.
-    case "${CT_ARCH}:${CT_ARCH_BITNESS}" in
-        x86:32)      arch=i386;;
-        x86:64)      arch=x86_64;;
-        sh:32)       arch="sh";;
-        *)           arch="${CT_ARCH}";;
-    esac
-    # Also remove stripping: its the responsibility of the
-    # firmware builder to strip or not.
-    ${sed} -i -r -e '/^TARGET_.*/d' "${dst}"
-    CT_KconfigEnableOption "TARGET_${arch}" "${dst}"
-    CT_KconfigSetOption "TARGET_ARCH" "${arch}" "${dst}"
-    CT_KconfigDisableOption "DOSTRIP" "${dst}"
-
-    # Ah. We may one day need architecture-specific handler here...
-    case "${arch}" in
-        arm*)
-            if [ "${CT_ARCH_ARM_EABI}" = "y" ]; then
-                CT_KconfigDisableOption "CONFIG_ARM_OABI" "${dst}"
-                CT_KconfigEnableOption "CONFIG_ARM_EABI" "${dst}"
-            else
-                CT_KconfigDisableOption "CONFIG_ARM_EABI" "${dst}"
-                CT_KconfigEnableOption "CONFIG_ARM_OABI" "${dst}"
-            fi
-            ;;
-        i386)
-            # FIXME This doesn't cover all cases of x86_32...
-            case ${CT_TARGET_ARCH} in
-                i386)
-                    CT_KconfigEnableOption "CONFIG_386" "${dst}"
-                    ;;
-                i486)
-                    CT_KconfigEnableOption "CONFIG_486" "${dst}"
-                    ;;
-                i586)
-                    CT_KconfigEnableOption "CONFIG_586" "${dst}"
-                    ;;
-                i686)
-                    CT_KconfigEnableOption "CONFIG_686" "${dst}"
-                    ;;
-            esac
-            ;;
-        mips*)
-            CT_KconfigDisableOption "CONFIG_MIPS_O32_ABI" "${dst}"
-            CT_KconfigDisableOption "CONFIG_MIPS_N32_ABI" "${dst}"
-            CT_KconfigDisableOption "CONFIG_MIPS_N64_ABI" "${dst}"
-            CT_KconfigDeleteOption "CONFIG_MIPS_ISA_1" "${dst}"
-            CT_KconfigDeleteOption "CONFIG_MIPS_ISA_2" "${dst}"
-            CT_KconfigDeleteOption "CONFIG_MIPS_ISA_3" "${dst}"
-            CT_KconfigDeleteOption "CONFIG_MIPS_ISA_4" "${dst}"
-            CT_KconfigDeleteOption "CONFIG_MIPS_ISA_MIPS32" "${dst}"
-            CT_KconfigDeleteOption "CONFIG_MIPS_ISA_MIPS32R2" "${dst}"
-            CT_KconfigDeleteOption "CONFIG_MIPS_ISA_MIPS64" "${dst}"
-            CT_KconfigDeleteOption "CONFIG_MIPS_ISA_MIPS64R2" "${dst}"
-            case "${CT_ARCH_mips_ABI}" in
-                32)
-                    CT_KconfigEnableOption "CONFIG_MIPS_O32_ABI" "${dst}"
-                    ;;
-                n32)
-                    CT_KconfigEnableOption "CONFIG_MIPS_N32_ABI" "${dst}"
-                    ;;
-                64)
-                    CT_KconfigEnableOption "CONFIG_MIPS_N64_ABI" "${dst}"
-                    ;;
-            esac
-            ;;
-        powerpc*)
-            CT_KconfigDisableOption "CONFIG_E500" "${dst}"
-            CT_KconfigDisableOption "CONFIG_CLASSIC" "${dst}"
-            CT_KconfigDeleteOption "TARGET_SUBARCH" "${dst}"
-            if [ "${CT_ARCH_powerpc_ABI}" = "spe" ]; then
-                CT_KconfigEnableOption "CONFIG_E500" "${dst}"
-                CT_KconfigSetOption "TARGET_SUBARCH" "e500" "${dst}"
-            else
-                CT_KconfigEnableOption "CONFIG_CLASSIC" "${dst}"
-                CT_KconfigSetOption "TARGET_SUBARCH" "classic" "${dst}"
-            fi
-            ;;
-        sh)
-            # all we really support right now is sh4:32
-            CT_KconfigEnableOption "CONFIG_SH4" "${dst}"
-            ;;
-    esac
-
-    # Accomodate for old and new uClibc versions, where the
-    # way to select between big/little endian has changed
     case "${CT_ARCH_ENDIAN}" in
         big)
             CT_KconfigDisableOption "ARCH_LITTLE_ENDIAN" "${dst}"
@@ -348,14 +272,18 @@ manage_uClibc_config() {
             ;;
     esac
 
-    # Accomodate for old and new uClibc versions, where the
-    # MMU settings has different config knobs
     if [ "${CT_ARCH_USE_MMU}" = "y" ]; then
         CT_KconfigEnableOption "ARCH_USE_MMU" "${dst}"
     else
         CT_KconfigDisableOption "ARCH_USE_MMU" "${dst}"
     fi
 
+    if [ "${CT_SHARED_LIBS}" = "y" ]; then
+        CT_KconfigEnableOption "HAVE_SHARED" "${dst}"
+    else
+        CT_KconfigDisableOption "HAVE_SHARED" "${dst}"
+    fi
+
     # Accomodate for old and new uClibc version, where the
     # way to select between hard/soft float has changed
     case "${CT_ARCH_FLOAT}" in
@@ -382,7 +310,6 @@ manage_uClibc_config() {
     # which is the correct value of ${PREFIX}/${TARGET}.
     CT_KconfigSetOption "DEVEL_PREFIX" "\"/usr/\"" "${dst}"
     CT_KconfigSetOption "RUNTIME_PREFIX" "\"/\"" "${dst}"
-    CT_KconfigSetOption "SHARED_LIB_LOADER_PREFIX" "\"/lib/\"" "${dst}"
     CT_KconfigSetOption "KERNEL_HEADERS" "\"${CT_HEADERS_DIR}\"" "${dst}"
 
     # Locales support
@@ -443,29 +370,23 @@ manage_uClibc_config() {
     fi
 
     # Push the threading model
+    CT_KconfigDisableOption "UCLIBC_HAS_THREADS" "${dst}"
+    CT_KconfigDisableOption "LINUXTHREADS_OLD" "${dst}"
+    CT_KconfigDisableOption "LINUXTHREADS_NEW" "${dst}"
+    CT_KconfigDisableOption "UCLIBC_HAS_THREADS_NATIVE" "${dst}"
     case "${CT_THREADS}:${CT_LIBC_UCLIBC_LNXTHRD}" in
         none:)
-            CT_KconfigDisableOption "UCLIBC_HAS_THREADS" "${dst}"
-            CT_KconfigDisableOption "LINUXTHREADS_OLD" "${dst}"
-            CT_KconfigDisableOption "LINUXTHREADS_NEW" "${dst}"
-            CT_KconfigDisableOption "UCLIBC_HAS_THREADS_NATIVE" "${dst}"
             ;;
         linuxthreads:old)
             CT_KconfigEnableOption "UCLIBC_HAS_THREADS" "${dst}"
             CT_KconfigEnableOption "LINUXTHREADS_OLD" "${dst}"
-            CT_KconfigDisableOption "LINUXTHREADS_NEW" "${dst}"
-            CT_KconfigDisableOption "UCLIBC_HAS_THREADS_NATIVE" "${dst}"
             ;;
         linuxthreads:new)
             CT_KconfigEnableOption "UCLIBC_HAS_THREADS" "${dst}"
-            CT_KconfigDisableOption "LINUXTHREADS_OLD" "${dst}"
             CT_KconfigEnableOption "LINUXTHREADS_NEW" "${dst}"
-            CT_KconfigDisableOption "UCLIBC_HAS_THREADS_NATIVE" "${dst}"
             ;;
         nptl:)
             CT_KconfigEnableOption "UCLIBC_HAS_THREADS" "${dst}"
-            CT_KconfigDisableOption "LINUXTHREADS_OLD" "${dst}"
-            CT_KconfigDisableOption "LINUXTHREADS_NEW" "${dst}"
             CT_KconfigEnableOption "UCLIBC_HAS_THREADS_NATIVE" "${dst}"
             ;;
         *)
@@ -477,29 +398,22 @@ manage_uClibc_config() {
     CT_KconfigEnableOption "PTHREADS_DEBUG_SUPPORT" "${dst}"
 
     # Force on debug options if asked for
+    CT_KconfigDisableOption "DODEBUG" "${dst}"
+    CT_KconfigDisableOption "DODEBUG_PT" "${dst}"
+    CT_KconfigDisableOption "DOASSERTS" "${dst}"
+    CT_KconfigDisableOption "SUPPORT_LD_DEBUG" "${dst}"
+    CT_KconfigDisableOption "SUPPORT_LD_DEBUG_EARLY" "${dst}"
+    CT_KconfigDisableOption "UCLIBC_MALLOC_DEBUGGING" "${dst}"
     case "${CT_LIBC_UCLIBC_DEBUG_LEVEL}" in
         0)
-            CT_KconfigDisableOption "DODEBUG" "${dst}"
-            CT_KconfigDisableOption "DODEBUG_PT" "${dst}"
-            CT_KconfigDisableOption "DOASSERTS" "${dst}"
-            CT_KconfigDisableOption "SUPPORT_LD_DEBUG" "${dst}"
-            CT_KconfigDisableOption "SUPPORT_LD_DEBUG_EARLY" "${dst}"
-            CT_KconfigDisableOption "UCLIBC_MALLOC_DEBUGGING" "${dst}"
             ;;
         1)
             CT_KconfigEnableOption "DODEBUG" "${dst}"
-            CT_KconfigDisableOption "DODEBUG_PT" "${dst}"
-            CT_KconfigDisableOption "DOASSERTS" "${dst}"
-            CT_KconfigDisableOption "SUPPORT_LD_DEBUG" "${dst}"
-            CT_KconfigDisableOption "SUPPORT_LD_DEBUG_EARLY" "${dst}"
-            CT_KconfigDisableOption "UCLIBC_MALLOC_DEBUGGING" "${dst}"
             ;;
         2)
             CT_KconfigEnableOption "DODEBUG" "${dst}"
-            CT_KconfigDisableOption "DODEBUG_PT" "${dst}"
             CT_KconfigEnableOption "DOASSERTS" "${dst}"
             CT_KconfigEnableOption "SUPPORT_LD_DEBUG" "${dst}"
-            CT_KconfigDisableOption "SUPPORT_LD_DEBUG_EARLY" "${dst}"
             CT_KconfigEnableOption "UCLIBC_MALLOC_DEBUGGING" "${dst}"
             ;;
         3)
@@ -511,8 +425,69 @@ manage_uClibc_config() {
             CT_KconfigEnableOption "UCLIBC_MALLOC_DEBUGGING" "${dst}"
             ;;
     esac
+
+    # Remove stripping: its the responsibility of the
+    # firmware builder to strip or not.
+    CT_KconfigDisableOption "DOSTRIP" "${dst}"
+
+    # Now allow architecture to tweak as it wants
+    CT_DoArchUClibcConfig "${dst}"
+    CT_DoArchUClibcCflags "${dst}" "${flags}"
 }
 
 do_libc_post_cc() {
-    :
+    # uClibc and GCC disagree where the dynamic linker lives. uClibc always
+    # places it in the MULTILIB_DIR, while gcc does that for *some* variants
+    # and expects it in /lib for the other. So, create a symlink from lib
+    # to the actual location, but only if that will not override the actual
+    # file in /lib. Thus, need to do this after all the variants are built.
+    # Moreover, need to do this after the final compiler is built: on targets
+    # that use elf2flt, the core compilers cannot find ld when running elf2flt.
+    CT_DoStep INFO "Checking dynamic linker symlinks"
+    CT_mkdir_pushd "${CT_BUILD_DIR}/build-libc-post_cc"
+    echo "int main(void) { return 0; }" > test-ldso.c
+    CT_IterateMultilibs do_libc_ldso_fixup ldso_fixup
+    CT_Popd
+    CT_EndStep
+}
+
+do_libc_ldso_fixup() {
+    local multi_dir multi_os_dir multi_root multi_flags multi_index multi_count
+    local binary
+    local ldso ldso_f ldso_d multilib_dir
+
+    for arg in "$@"; do
+        eval "${arg// /\\ }"
+    done
+
+    CT_DoLog EXTRA "Checking dynamic linker for multilib '${multi_flags}'"
+
+    multilib_dir="/lib/${multi_os_dir}"
+    CT_SanitizeVarDir multilib_dir
+
+    CT_DoExecLog ALL "${CT_TARGET}-gcc" -o test-ldso ../test-ldso.c ${multi_flags}
+    if [ -r "test-ldso.gdb" ]; then
+        binary="test-ldso.gdb"
+    else
+        binary="test-ldso"
+    fi
+    if ${CT_TARGET}-readelf -Wl "${binary}" | grep -q 'Requesting program interpreter: '; then
+        ldso=$( ${CT_TARGET}-readelf -Wl "${binary}" | \
+            grep 'Requesting program interpreter: ' | \
+            sed -e 's,.*: ,,' -e 's,\].*,,' )
+    fi
+    CT_DoLog DEBUG "Detected dynamic linker for multilib '${multi_flags}': '${ldso}'"
+
+    ldso_d="${ldso%/ld*.so.*}"
+    ldso_f="${ldso##*/}"
+    # Create symlink if GCC produced an executable, dynamically linked, it was requesting
+    # a linker not in the current directory, and there is no such file in the expected
+    # ldso dir.
+    if [ -n "${ldso}" -a "${ldso_d}" != "${multilib_dir}" -a ! -r "${multi_root}${ldso}" ]; then
+        # Convert ldso_d to "how many levels we need to go up" and remove
+        # leading slash.
+        ldso_d=$( echo "${ldso_d#/}" | sed 's,[^/]\+,..,g' )
+        CT_DoExecLog ALL ln -sf "${ldso_d}${multilib_dir}/${ldso_f}" \
+            "${multi_root}${ldso}"
+    fi
 }