Huge fixes to glibc build, so that we can build at least (and at last):

 - use ports addon even when installing headers,
 - use optimisation (-O) when installing headers, to avoid unnecessary warnings (thanks Robert P. J. DAY for pointing this out!),
 - lowest kernel version to use is only X.Y.Z, not X.Y.Z.T,
 - a bit of preparations for NPTL (RSN I hope),
 - fix fixing the linker scripts (changing the backup file is kind of useless and stupid);

Shut uClibc finish step: there really is nothing to do;

Add a patch for glibc-2.3.6 weak aliases handling on some archs (ARM and ALPHA at least);

Did not catch the make errors: fixed the pattern matching in scripts/functions;

Introduce a new log level, ALL:
 - send components' build messages there,
 - DEBUG log level is destined only for crosstool-NG debug messages,
 - migrate sub-actions to use appropriate log levels;

Update the armeb-unknown-linux-gnu sample:
 - it builds!
 - uses gcc-4.0.4 and glibc-2.3.6,
 - updated to latest config options set.

7 files changed, 73 insertions, 62 deletions

diff --git a/scripts/build/binutils.sh b/scripts/build/binutils.sh
index 7a3497d..d2ab56f 100644
--- a/scripts/build/binutils.sh
+++ b/scripts/build/binutils.sh
@@ -30,13 +30,13 @@ do_binutils() {
         --prefix=${CT_PREFIX_DIR}                   \
         --disable-nls                               \
         ${CT_BINUTILS_EXTRA_CONFIG}                 \
-        ${BINUTILS_SYSROOT_ARG}                     2>&1 |CT_DoLog DEBUG
+        ${BINUTILS_SYSROOT_ARG}                     2>&1 |CT_DoLog ALL
 
     CT_DoLog EXTRA "Building binutils"
-    make ${PARALLELMFLAGS}  2>&1 |CT_DoLog DEBUG
+    make ${PARALLELMFLAGS}  2>&1 |CT_DoLog ALL
 
     CT_DoLog EXTRA "Installing binutils"
-    make install            2>&1 |CT_DoLog DEBUG
+    make install            2>&1 |CT_DoLog ALL
 
     # Make those new tools available to the core C compiler to come:
     # Note: some components want the ${TARGET}-{ar,as,ld,strip} commands as
@@ -46,7 +46,7 @@ do_binutils() {
     for t in ar as ld strip; do
         ln -sv "${CT_PREFIX_DIR}/bin/${CT_TARGET}-${t}" "${CT_CC_CORE_PREFIX_DIR}/${CT_TARGET}/bin/${t}"
         ln -sv "${CT_PREFIX_DIR}/bin/${CT_TARGET}-${t}" "${CT_CC_CORE_PREFIX_DIR}/bin/${CT_TARGET}-${t}"
-    done |CT_DoLog DEBUG
+    done |CT_DoLog ALL
 
     CT_EndStep
 }
diff --git a/scripts/build/cc_core_gcc.sh b/scripts/build/cc_core_gcc.sh
index 68b9475..b12b8ba 100644
--- a/scripts/build/cc_core_gcc.sh
+++ b/scripts/build/cc_core_gcc.sh
@@ -62,18 +62,18 @@ do_cc_core() {
         --enable-symvers=gnu                        \
         --enable-languages=c                        \
         --disable-shared                            \
-        ${CT_CC_CORE_EXTRA_CONFIG}                  2>&1 |CT_DoLog DEBUG
+        ${CT_CC_CORE_EXTRA_CONFIG}                  2>&1 |CT_DoLog ALL
 
     if [ ! "${CT_CANADIAN}" = "y" ]; then
         CT_DoLog EXTRA "Building libiberty"
-        make ${PARALLELMFLAGS} all-build-libiberty 2>&1 |CT_DoLog DEBUG
+        make ${PARALLELMFLAGS} all-build-libiberty 2>&1 |CT_DoLog ALL
     fi
 
     CT_DoLog EXTRA "Building core C compiler"
-    make ${PARALLELMFLAGS} all-gcc 2>&1 |CT_DoLog DEBUG
+    make ${PARALLELMFLAGS} all-gcc 2>&1 |CT_DoLog ALL
 
     CT_DoLog EXTRA "Installing core C compiler"
-    make install-gcc 2>&1 |CT_DoLog DEBUG
+    make install-gcc 2>&1 |CT_DoLog ALL
 
     CT_EndStep
 }
diff --git a/scripts/build/cc_gcc.sh b/scripts/build/cc_gcc.sh
index b7d36ee..54ebddf 100644
--- a/scripts/build/cc_gcc.sh
+++ b/scripts/build/cc_gcc.sh
@@ -80,11 +80,11 @@ do_cc() {
         --enable-symvers=gnu                    \
         --enable-c99                            \
         --enable-long-long                      \
-        ${CT_CC_EXTRA_CONFIG}                   2>&1 |CT_DoLog DEBUG
+        ${CT_CC_EXTRA_CONFIG}                   2>&1 |CT_DoLog ALL
 
     if [ ! "${CT_CANADIAN}" = "y" ]; then
         CT_DoLog EXTRA "Building libiberty"
-        make ${PARALLELMFLAGS} all-build-libiberty 2>&1 |CT_DoLog DEBUG
+        make ${PARALLELMFLAGS} all-build-libiberty 2>&1 |CT_DoLog ALL
     fi
 
 
@@ -109,10 +109,10 @@ do_cc() {
     esac
 
     CT_DoLog EXTRA "Building final compiler"
-    make ${PARALLELMFLAGS} all 2>&1 |CT_DoLog DEBUG
+    make ${PARALLELMFLAGS} all 2>&1 |CT_DoLog ALL
 
     CT_DoLog EXTRA "Installing final compiler"
-    make install 2>&1 |CT_DoLog DEBUG
+    make install 2>&1 |CT_DoLog ALL
 
     # FIXME: shouldn't people who want this just --disable-multilib in final gcc
     # and be done with it?
diff --git a/scripts/build/kernel_linux.sh b/scripts/build/kernel_linux.sh
index 9c1a004..fd50d23 100644
--- a/scripts/build/kernel_linux.sh
+++ b/scripts/build/kernel_linux.sh
@@ -40,7 +40,7 @@ do_kernel_check_config() {
         mkdir -p "${CT_BUILD_DIR}/build-kernel-defconfig"
         cd "${CT_BUILD_DIR}/build-kernel-defconfig"
         make -C "${CT_SRC_DIR}/${CT_KERNEL_FILE}" O=`pwd`   \
-             ARCH=${CT_KERNEL_ARCH} defconfig               2>&1 |CT_DoLog DEBUG
+             ARCH=${CT_KERNEL_ARCH} defconfig               2>&1 |CT_DoLog ALL
 
         CT_KERNEL_LINUX_CONFIG_FILE="`pwd`/.config"
 
@@ -92,7 +92,7 @@ do_kernel_headers() {
 
 # Install kernel headers using headers_install from kernel sources.
 do_kernel_install() {
-    CT_DoLog EXTRA "Using kernel's headers_install"
+    CT_DoLog DEBUG "Using kernel's headers_install"
 
     mkdir -p "${CT_BUILD_DIR}/build-kernel-headers"
     cd "${CT_BUILD_DIR}/build-kernel-headers"
@@ -108,7 +108,7 @@ do_kernel_install() {
          ARCH=${CT_KERNEL_ARCH}                     \
          INSTALL_HDR_PATH="${CT_SYSROOT_DIR}/usr"   \
          ${V_OPT}                                   \
-         headers_install                            2>&1 |CT_DoLog DEBUG
+         headers_install                            2>&1 |CT_DoLog ALL
 
     CT_DoLog EXTRA "Checking installed headers"
     make -C "${CT_SRC_DIR}/${CT_KERNEL_FILE}"       \
@@ -116,20 +116,20 @@ do_kernel_install() {
          ARCH=${CT_KERNEL_ARCH}                     \
          INSTALL_HDR_PATH="${CT_SYSROOT_DIR}/usr"   \
          ${V_OPT}                                   \
-         headers_check                              2>&1 |CT_DoLog DEBUG
+         headers_check                              2>&1 |CT_DoLog ALL
 }
 
 # Install kernel headers from oldish Mazur's sanitised headers.
 do_kernel_sanitised() {
     CT_DoLog EXTRA "Copying sanitised headers"
     cd "${CT_SRC_DIR}/${CT_KERNEL_FILE}"
-    cp -rv include/linux "${CT_HEADERS_DIR}" 2>&1 |CT_DoLog DEBUG
-    cp -rv "include/asm-${CT_KERNEL_ARCH}" "${CT_HEADERS_DIR}/asm" 2>&1 |CT_DoLog DEBUG
+    cp -rv include/linux "${CT_HEADERS_DIR}" 2>&1 |CT_DoLog ALL
+    cp -rv "include/asm-${CT_KERNEL_ARCH}" "${CT_HEADERS_DIR}/asm" 2>&1 |CT_DoLog ALL
 }
 
 # Install kernel headers by plain copy.
 do_kernel_copy() {
-    CT_DoLog EXTRA "Copying plain kernel headers"
+    CT_DoLog DEBUG "Copying plain kernel headers"
     CT_DoLog WARN "You are using plain kernel headers. You really shouldn't do that."
     CT_DoLog WARN "You'd be better off by using installed headers (or sanitised headers)."
 
@@ -178,12 +178,12 @@ do_kernel_copy() {
                                  ;;
                  esac
                  ;;
-    esac 2>&1 |CT_DoLog DEBUG
+    esac 2>&1 |CT_DoLog ALL
 
     CT_DoLog EXTRA "Copying kernel headers"
-    cp -rv include/asm-generic "${CT_HEADERS_DIR}/asm-generic" 2>&1 |CT_DoLog DEBUG
-    cp -rv include/linux "${CT_HEADERS_DIR}" 2>&1 |CT_DoLog DEBUG
-    cp -rv include/asm-${CT_KERNEL_ARCH} "${CT_HEADERS_DIR}/asm" 2>&1 |CT_DoLog DEBUG
+    cp -rv include/asm-generic "${CT_HEADERS_DIR}/asm-generic" 2>&1 |CT_DoLog ALL
+    cp -rv include/linux "${CT_HEADERS_DIR}" 2>&1 |CT_DoLog ALL
+    cp -rv include/asm-${CT_KERNEL_ARCH} "${CT_HEADERS_DIR}/asm" 2>&1 |CT_DoLog ALL
 }
 
 # Use preinstalled headers (most probably by using make headers_install in a
@@ -194,5 +194,5 @@ do_kernel_preinstalled() {
 
     mkdir -p "${CT_SYSROOT_DIR}/usr"
     cd "${CT_KERNEL_LINUX_HEADERS_CUSTOM_DIR}"
-    cp -rv include "${CT_SYSROOT_DIR}/usr" 2>&1 |CT_DoLog DEBUG
+    cp -rv include "${CT_SYSROOT_DIR}/usr" 2>&1 |CT_DoLog ALL
 }
diff --git a/scripts/build/libc_glibc.sh b/scripts/build/libc_glibc.sh
index 9f7f69c..41be59a 100644
--- a/scripts/build/libc_glibc.sh
+++ b/scripts/build/libc_glibc.sh
@@ -10,7 +10,7 @@ do_libc_get() {
     CT_GetFile "${CT_LIBC_FILE}" ftp://ftp.gnu.org/gnu/glibc
 
     # C library addons
-    addons_list=`echo "${CT_LIBC_ADDONS}" |sed -r -e 's/,/ /g; s/ $//g;'`
+    addons_list=`echo "${CT_LIBC_ADDONS_LIST}" |sed -r -e 's/,/ /g; s/ $//g;'`
     for addon in ${addons_list}; do
         CT_GetFile "${CT_LIBC}-${addon}-${CT_LIBC_VERSION}" ftp://ftp.gnu.org/gnu/glibc
     done
@@ -24,7 +24,7 @@ do_libc_extract() {
     CT_ExtractAndPatch "${CT_LIBC_FILE}"
 
     # C library addons
-    addons_list=`echo "${CT_LIBC_ADDONS}" |sed -r -e 's/,/ /g; s/ $//g;'`
+    addons_list=`echo "${CT_LIBC_ADDONS_LIST}" |sed -r -e 's/,/ /g; s/ $//g;'`
     for addon in ${addons_list}; do
         CT_ExtractAndPatch "${CT_LIBC}-${addon}-${CT_LIBC_VERSION}"
     done
@@ -66,6 +66,11 @@ do_libc_headers() {
     # is ok here, since all we want are the basic headers at this point.
     # Override libc_cv_ppc_machine so glibc-cvs doesn't complain
     # 'a version of binutils that supports .machine "altivec" is needed'.
+
+    # We also need to use the ports addon if specified
+    addons=
+    [ "${CT_LIBC_GLIBC_USE_PORTS}" = "y" ] && addons="${CT_LIBC}-ports-${CT_LIBC_VERSION}"
+
     libc_cv_ppc_machine=yes                     \
     CC=${CT_CC_NATIVE}                          \
     "${CT_SRC_DIR}/${CT_LIBC_FILE}/configure"   \
@@ -76,8 +81,8 @@ do_libc_headers() {
         --without-cvs                           \
         --disable-sanity-checks                 \
         --enable-hacker-mode                    \
-        --enable-add-ons=""                     \
-        --without-nptl                          2>&1 |CT_DoLog DEBUG
+        --enable-add-ons="${addons}"            \
+        --without-nptl                          2>&1 |CT_DoLog ALL
 
     CT_DoLog EXTRA "Installing C library headers"
 
@@ -93,9 +98,11 @@ do_libc_headers() {
         # errlist-compat.c.
         # Note: BOOTSTRAP_GCC is used by:
         # patches/glibc-2.3.5/glibc-mips-bootstrap-gcc-header-install.patch
-        libc_cv_ppc_machine=yes                             \
-        make CFLAGS=-DBOOTSTRAP_GCC sysdeps/gnu/errlist.c   2>&1 |CT_DoLog DEBUG
+
+        libc_cv_ppc_machine=yes                                 \
+        make CFLAGS="-O -DBOOTSTRAP_GCC" sysdeps/gnu/errlist.c  2>&1 |CT_DoLog ALL
         mkdir -p stdio-common
+
         # sleep for 2 seconds for benefit of filesystems with lousy time
         # resolution, like FAT, so make knows for sure errlist-compat.c doesn't
         # need generating
@@ -105,8 +112,8 @@ do_libc_headers() {
     # Note: BOOTSTRAP_GCC (see above)
     libc_cv_ppc_machine=yes                                 \
     make cross-compiling=yes install_root=${CT_SYSROOT_DIR} \
-        CFLAGS=-DBOOTSTRAP_GCC ${LIBC_SYSROOT_ARG}          \
-        install-headers                                     2>&1 |CT_DoLog DEBUG
+         CFLAGS="-O -DBOOTSTRAP_GCC" ${LIBC_SYSROOT_ARG}    \
+         install-headers                                    2>&1 |CT_DoLog ALL
 
     # Two headers -- stubs.h and features.h -- aren't installed by install-headers,
     # so do them by hand.  We can tolerate an empty stubs.h for the moment.
@@ -142,7 +149,7 @@ do_libc() {
     extra_config=""
     case "${CT_LIBC_GLIBC_EXTRA_CONFIG}" in
         *enable-kernel*) ;;
-        *) extra_config="${extra_config} --enable-kernel=${CT_KERNEL_VERSION}"
+        *) extra_config="${extra_config} --enable-kernel=`echo ${CT_KERNEL_VERSION} |sed -r -e 's/^([^.]+\.[^.]+\.[^.]+)(|\.[^.]+)$/\1/;'`"
     esac
     case "${CT_LIBC_GLIBC_EXTRA_CONFIG}" in
         *-tls*) ;;
@@ -164,12 +171,13 @@ do_libc() {
                 ,y) extra_config="${extra_config} --without-fp";;
             esac;;
     esac
-    case "${CT_LIBC_ADDONS},${CT_LIBC_ADDONS_LIST}" in
-        y,) extra_config="${extra_config} --enable-add-ons";;
-        y,*) extra_config="${extra_config} --enable-add-ons=${CT_LIBC_ADDONS_LIST}";;
-    esac
 
-    CT_DoLog DEBUG "Extra config args passed: \"${extra_config}\""
+    case "${CT_LIBC_ADDONS},${CT_LIBC_GLIBC_USE_PORTS}" in
+        y,y)    addons_config="--enable-add-ons=${CT_LIBC_ADDONS_LIST},${CT_LIBC}-ports-${CT_LIBC_VERSION}";;
+        y,)     addons_config="--enable-add-ons=${CT_LIBC_ADDONS_LIST}";;
+        ,y)     addons_config="--enable-add-ons=${CT_LIBC}-ports-${CT_LIBC_VERSION}";;
+        *)      addons_config="";;
+    esac
 
     # Add some default CC args
     extra_cc_args="${CT_CFLAGS_FOR_HOST}"
@@ -182,6 +190,8 @@ do_libc() {
             esac;;
     esac
 
+    CT_DoLog DEBUG "Configuring with addons : \"${addons_config}\""
+    CT_DoLog DEBUG "Extra config args passed: \"${extra_config}\""
     CT_DoLog DEBUG "Extra CC args passed: \"${extra_cc_args}\""
 
     # sh3 and sh4 really need to set configparms as of gcc-3.4/glibc-2.3.2
@@ -214,13 +224,15 @@ do_libc() {
     "${CT_SRC_DIR}/${CT_LIBC_FILE}/configure"                       \
         --prefix=/usr                                               \
         --build=${CT_BUILD} --host=${CT_TARGET}                     \
-        ${CT_LIBC_GLIBC_EXTRA_CONFIG}                               \
-        ${extra_config}                                             \
         --without-cvs                                               \
+        --without-nptl                                              \
         --disable-profile                                           \
         --disable-debug                                             \
         --without-gd                                                \
-        --with-headers="${CT_HEADERS_DIR}"                          2>&1 |CT_DoLog DEBUG
+        --with-headers="${CT_HEADERS_DIR}"                          \
+        ${addons_config}                                            \
+        ${extra_config}                                             \
+        ${CT_LIBC_GLIBC_EXTRA_CONFIG}                               2>&1 |CT_DoLog ALL
 
     if grep -l '^install-lib-all:' "${CT_SRC_DIR}/${CT_LIBC_FILE}/Makerules" > /dev/null; then
         # nptl-era glibc.
@@ -248,17 +260,17 @@ do_libc() {
     CT_DoLog EXTRA "Building C library"
     make LD=${CT_TARGET}-ld             \
          RANLIB=${CT_TARGET}-ranlib     \
-         ${GLIBC_INITIAL_BUILD_RULE}    2>&1 |CT_DoLog DEBUG
+         ${GLIBC_INITIAL_BUILD_RULE}    2>&1 |CT_DoLog ALL
 
     CT_DoLog EXTRA "Installing C library"
     make install_root="${CT_SYSROOT_DIR}"   \
          ${LIBC_SYSROOT_ARG}                \
-         ${GLIBC_INITIAL_INSTALL_RULE}      2>&1 |CT_DoLog DEBUG
+         ${GLIBC_INITIAL_INSTALL_RULE}      2>&1 |CT_DoLog ALL
 
     # This doesn't seem to work when building a crosscompiler,
     # as it tries to execute localedef using the just-built ld.so!?
     #CT_DoLog EXTRA "Installing locales"
-    #make localedata/install-locales install_root=${SYSROOT} 2>&1 |CT_DoLog DEBUG
+    #make localedata/install-locales install_root=${SYSROOT} 2>&1 |CT_DoLog ALL
 
     # Fix problems in linker scripts.
     #
@@ -276,13 +288,13 @@ do_libc() {
     for file in libc.so libpthread.so libgcc_s.so; do
         for dir in lib lib64 usr/lib usr/lib64; do
             if [ -f "${CT_SYSROOT_DIR}/${dir}/${file}" -a ! -L ${CT_SYSROOT_DIR}/$lib/$file ]; then
-                mv "${CT_SYSROOT_DIR}/${dir}/${file}" "${CT_SYSROOT_DIR}/${dir}/${file}_orig"
+                cp "${CT_SYSROOT_DIR}/${dir}/${file}" "${CT_SYSROOT_DIR}/${dir}/${file}_orig"
                 CT_DoLog DEBUG "Fixing \"${CT_SYS_ROOT_DIR}/${dir}/${file}\""
                 sed -i -r -e 's,/usr/lib/,,g;
                               s,/usr/lib64/,,g;
                               s,/lib/,,g;
                               s,/lib64/,,g;
-                              /BUG in libc.scripts.output-format.sed/d' "${CT_SYSROOT_DIR}/${dir}/${file}_orig"
+                              /BUG in libc.scripts.output-format.sed/d' "${CT_SYSROOT_DIR}/${dir}/${file}"
             fi
         done
     done
@@ -303,13 +315,15 @@ do_libc_finish() {
     cd "${CT_BUILD_DIR}/build-libc"
 
     CT_DoLog EXTRA "Re-building C library"
-    make LD=${CT_TARGET}-ld RANLIB=${CT_TARGET}-ranlib 2>&1 |CT_DoLog DEBUG
+    make LD=${CT_TARGET}-ld RANLIB=${CT_TARGET}-ranlib 2>&1 |CT_DoLog ALL
 
     CT_DoLog EXTRA "Installing missing C library components"
     # note: should do full install and then fix linker scripts, but this is faster
     for t in bin rootsbin sbin data others; do
         make install_root="${CT_SYSROOT_DIR}"   \
              ${LIBC_SYSROOT_ARG}                \
-             install-${t}                       2>&1 |CT_DoLog DEBUG
+             install-${t}                       2>&1 |CT_DoLog ALL
     done
+
+    CT_EndStep
 }
diff --git a/scripts/build/libc_libfloat.sh b/scripts/build/libc_libfloat.sh
index d40070f..70b95c2 100644
--- a/scripts/build/libc_libfloat.sh
+++ b/scripts/build/libc_libfloat.sh
@@ -41,17 +41,17 @@ do_libfloat() {
     CT_DoLog EXTRA "Copying sources to build dir"
     mkdir build-libfloat
     cd build-libfloat
-    ( cd "${CT_SRC_DIR}/${CT_LIBFLOAT_FILE}"; tar cf - . ) |tar xvf - |CT_DoLog DEBUG
+    ( cd "${CT_SRC_DIR}/${CT_LIBFLOAT_FILE}"; tar cf - . ) |tar xvf - |CT_DoLog ALL
 
     CT_DoLog EXTRA "Cleaning library"
-    make clean 2>&1 |CT_DoLog DEBUG
+    make clean 2>&1 |CT_DoLog ALL
 
     CT_DoLog EXTRA "Building library"
-    make CROSS_COMPILE="${CT_CC_CORE_PREFIX_DIR}/bin/${CT_TARGET}-" 2>&1 |CT_DoLog DEBUG
+    make CROSS_COMPILE="${CT_CC_CORE_PREFIX_DIR}/bin/${CT_TARGET}-" 2>&1 |CT_DoLog ALL
 
     CT_DoLog EXTRA "Installing library"
     make CROSS_COMPILE="${CT_CC_CORE_PREFIX_DIR}/bin/${CT_TARGET}-" \
-         DESTDIR="${CT_SYSROOT_DIR}" install                       2>&1 |CT_DoLog DEBUG
+         DESTDIR="${CT_SYSROOT_DIR}" install                       2>&1 |CT_DoLog ALL
 
     CT_Popd
 
diff --git a/scripts/build/libc_uClibc.sh b/scripts/build/libc_uClibc.sh
index 0981ce9..1b8f99e 100644
--- a/scripts/build/libc_uClibc.sh
+++ b/scripts/build/libc_uClibc.sh
@@ -68,13 +68,13 @@ do_libc_headers() {
     # use of the native build host tools, which we need at this
     # stage, as we don't have target tools yet.
     CT_DoLog EXTRA "Applying configuration"
-    CT_DoYes "" |make CROSS= PREFIX="${CT_SYSROOT_DIR}/" oldconfig 2>&1 |CT_DoLog DEBUG
+    CT_DoYes "" |make CROSS= PREFIX="${CT_SYSROOT_DIR}/" oldconfig 2>&1 |CT_DoLog ALL
 
     CT_DoLog EXTRA "Building headers"
-    make ${PARALLELMFLAGS} CROSS= PREFIX="${CT_SYSROOT_DIR}/" headers 2>&1 |CT_DoLog DEBUG
+    make ${PARALLELMFLAGS} CROSS= PREFIX="${CT_SYSROOT_DIR}/" headers 2>&1 |CT_DoLog ALL
 
     CT_DoLog EXTRA "Installing headers"
-    make CROSS= PREFIX="${CT_SYSROOT_DIR}/" install_dev 2>&1 |CT_DoLog DEBUG
+    make CROSS= PREFIX="${CT_SYSROOT_DIR}/" install_dev 2>&1 |CT_DoLog ALL
 
     CT_EndStep
 }
@@ -104,7 +104,7 @@ do_libc() {
     CT_DoYes "" |make ${PARALLELMFLAGS}             \
                       CROSS=${CT_TARGET}-           \
                       PREFIX="${CT_SYSROOT_DIR}/"   \
-                      oldconfig                     2>&1 |CT_DoLog DEBUG
+                      oldconfig                     2>&1 |CT_DoLog ALL
 
     # We do _not_ want to strip anything for now, in case we specifically
     # asked for a debug toolchain, thus the STRIPTOOL= assignment
@@ -113,7 +113,7 @@ do_libc() {
          CROSS=${CT_TARGET}-            \
          PREFIX="${CT_SYSROOT_DIR}/"    \
          STRIPTOOL=true                 \
-         all                            2>&1 |CT_DoLog DEBUG
+         all                            2>&1 |CT_DoLog ALL
 
     # YEM-FIXME: we want to install libraries in $SYSROOT/lib, but we don't want
     # to install headers in $SYSROOT/include, thus making only install_runtime.
@@ -127,17 +127,14 @@ do_libc() {
     make CROSS=${CT_TARGET}-            \
          PREFIX="${CT_SYSROOT_DIR}/"    \
          STRIPTOOL=true                 \
-         install                        2>&1 |CT_DoLog DEBUG
+         install                        2>&1 |CT_DoLog ALL
 
     CT_EndStep
 }
 
 # This function is used to install those components needing the final C compiler
 do_libc_finish() {
-    CT_DoStep INFO "Finishing C library"
-    # uClibc has nothing to finish
-    CT_DoLog EXTRA "uClibc has nothing to finish"
-    CT_EndStep
+    :
 }
 
 # Initialises the .config file to sensible values