diff --git a/sdk_lib/make_chroot.sh b/sdk_lib/make_chroot.sh
index a04ff29246..4aaeb33c1c 100755
--- a/sdk_lib/make_chroot.sh
+++ b/sdk_lib/make_chroot.sh
@@ -396,15 +396,19 @@ sudo sh -c "echo STAGE3=$STAGE3 > $CHROOT_STATE"
 info "Updating portage"
 early_enter_chroot emerge -uNv --quiet portage
 
-info "Updating host toolchain"
-early_enter_chroot emerge -uNv --quiet crossdev
-TOOLCHAIN_ARGS=( --deleteold )
-if [[ ${FLAGS_usepkg} -eq ${FLAGS_FALSE} ]]; then
-  TOOLCHAIN_ARGS+=( --nousepkg )
-fi
-# Note: early_enter_chroot executes as root.
-early_enter_chroot "${CHROOT_TRUNK}/chromite/bin/cros_setup_toolchains" \
-    --hostonly "${TOOLCHAIN_ARGS[@]}"
+info "Updating toolchain"
+early_enter_chroot emerge -uNv --quiet $USEPKG '>=sys-devel/gcc-4.4' \
+  sys-libs/glibc sys-devel/binutils sys-kernel/linux-headers
+
+# HACK: Select the latest toolchain. We're assuming that when this is
+# ran, the chroot has no experimental versions of new toolchains, just
+# one that is very old, and one that was just emerged.
+GCC_ATOM="$(early_enter_chroot portageq best_version / sys-devel/gcc)"
+early_enter_chroot emerge --unmerge "<${GCC_ATOM}"
+CHOST="$(early_enter_chroot portageq envvar CHOST)"
+LATEST="$(early_enter_chroot gcc-config -l | grep "${CHOST}" | tail -n1 | \
+          cut -f3 -d' ')"
+early_enter_chroot gcc-config "${LATEST}"
 
 # dhcpcd is included in 'world' by the stage3 that we pull in for some reason.
 # We have no need to install it in our host environment, so pull it out here.
@@ -423,10 +427,8 @@ if [ -n "${INITIALIZE_CHROOT}" ]; then
 fi
 
 # Update chroot.
-# Skip toolchain update because it already happened above, and the chroot is
-# not ready to emerge all cross toolchains.
-UPDATE_ARGS=( --skip_toolchain_update )
-if [[ ${FLAGS_usepkg} -eq ${FLAGS_TRUE} ]]; then
+UPDATE_ARGS=()
+if [[ $FLAGS_usepkg -eq $FLAGS_TRUE ]]; then
   UPDATE_ARGS+=( --usepkg )
 else
   UPDATE_ARGS+=( --nousepkg )
@@ -446,11 +448,6 @@ if [[ "$FLAGS_chroot" != "$DEFAULT_CHROOT_DIR" ]]; then
   CHROOT_EXAMPLE_OPT="--chroot=$FLAGS_chroot"
 fi
 
-# As a final pass, build all desired cross-toolchains.
-info "Updating toolchains"
-enter_chroot sudo "${CHROOT_TRUNK}/chromite/bin/cros_setup_toolchains" \
-    "${TOOLCHAIN_ARGS[@]}"
-
 print_time_elapsed
 
 cat <<EOF
diff --git a/setup_board b/setup_board
index f44ba0aba7..38b2765ea1 100755
--- a/setup_board
+++ b/setup_board
@@ -131,6 +131,139 @@ board_needs_libc_update() {
   return 0
 }
 
+# Check whether any new toolchain packages are available.
+# Returns true if new toolchain packages are available and false otherwise.
+toolchain_needs_update() {
+  # Skip toolchain updates if requested.
+  if [ $FLAGS_skip_toolchain_update -eq $FLAGS_TRUE ]; then
+    return 1
+  fi
+
+  local toolchain=$1 crossdev_cfg category arch
+
+  # Query crossdev for how it will be laying things out.
+  crossdev_cfg=$(crossdev --show-target-cfg "${toolchain}" --ex-gdb)
+  category=$(eval "${crossdev_cfg}"; echo "${category}")
+  arch=$(eval "${crossdev_cfg}"; echo "${arch}")
+
+  # If toolchain symlinks weren't created yet, we definitely need to update.
+  if [ ! -d ${CROSSDEV_OVERLAY}/${category} ]; then
+    # NOTE: In this branch, the versions have not been resolved, and will
+    # be passed directly to crossdev. That works because crossdev understands
+    # '[stable]'.
+    # We cannot resolve the versions because the cross toolchain category is
+    # not yet set up.
+    return 0
+  fi
+
+  # Unmask any ebuilds previously [un]masked by crossdev. crossdev will
+  # re-setup its masks appropriately the next time we run it.
+  local d
+  for d in package.{mask,keywords} ; do
+    d="/etc/portage/${d}"
+    if [[ -e ${d}/${category} ]] ; then
+      sudo mv -f ${d}/{,.bak.}${category}
+    fi
+  done
+
+  # Now get the atoms out of crossdev for the emerge below.
+  local pfx
+  if [[ ${FLAGS_latest_toolchain} -eq ${FLAGS_TRUE} ]] ; then
+    pfx=""
+  elif [[ ${FLAGS_usepkg} -eq ${FLAGS_TRUE} ]] ; then
+    pfx="<="
+  else
+    pfx="="
+  fi
+
+  local crosspkgs=$(eval "${crossdev_cfg}"; echo "${crosspkgs}")
+  local pkgs=()
+  for pkg in ${crosspkgs} ; do
+    local pn=$(eval "${crossdev_cfg}" \; echo \${${pkg}_pn})
+    local atom="${category}/${pn}"
+
+    if [[ -z ${pn} ]] ; then
+      # Not all toolchains provide all packages
+      # e.g. arm-elf does not have "kernel" headers.
+      continue
+    fi
+
+    if [[ ${FLAGS_latest_toolchain} -ne ${FLAGS_TRUE} ]] ; then
+      local flagname="FLAGS_${pkg}_version"
+
+      # Some packages (like gdb) don't have pinned versions.
+      if [[ -n ${!flagname} ]] ; then
+        if [[ ${!flagname} == "[stable]" ]] ; then
+          # This will return the full cat/pn-ver for us.
+          atom="${pfx}"$(ACCEPT_KEYWORDS="${arch}" \
+                         portageq best_visible / ebuild "${atom}")
+        else
+          atom="${pfx}${atom}-${!flagname}"
+        fi
+      fi
+    fi
+
+    pkgs+=( "${atom}" )
+  done
+
+  local flags=( --pretend --quiet --update --nodeps )
+  if [[ ${FLAGS_usepkg} -eq ${FLAGS_TRUE} ]] ; then
+    flags+=( --getbinpkg --usepkgonly )
+  fi
+
+  ACCEPT_KEYWORDS="~* *" emerge "${flags[@]}" "${pkgs[@]}" | grep ${category}/
+  local ret=$?
+
+  # Restore the masks in case we don't end up running crossdev.
+  for d in package.{mask,keywords} ; do
+    d="/etc/portage/${d}"
+    if [[ -e ${d}/.bak.${category} ]] ; then
+      sudo mv -f ${d}/{.bak.,}${category}
+    fi
+  done
+
+  return ${ret}
+}
+
+uninstall_toolchain() {
+  local toolchain=$1
+  info "Uninstalling the toolchain."
+  # Even if the uninstall fails, keep going. It's likely
+  # that it didn't exist in the first place.
+  sudo crossdev -v --force -C "${toolchain}" || true
+}
+
+# Build the toolchain with crossdev.
+build_toolchain() {
+  local toolchain=$1
+  info "Building the toolchain."
+  local CROSS_ARGS=( --show-fail-log --target "${toolchain}" -P --oneshot )
+  if [ $FLAGS_usepkg -eq $FLAGS_TRUE ]; then
+    # Grab the latest packages from the prebuilt server.
+    #  --getbinpkg: Use packages from the prebuilt server.
+    #  --usepkgonly: Always use prebuilts. Don't build from source.
+    #  --without-headers: Don't build headers-only versions of packages for
+    #                     bootstrapping. Because we use binary packages, this
+    #                     isn't necessary.
+    CROSS_ARGS+=( -P --getbinpkg -P --usepkgonly --without-headers )
+  fi
+  if [ $FLAGS_latest_toolchain -ne $FLAGS_TRUE ]; then
+    CROSS_ARGS+=(
+      --binutils "${FLAGS_binutils_version}"
+      --gcc "${FLAGS_gcc_version}"
+      --kernel "${FLAGS_kernel_version}"
+      --libc "${FLAGS_libc_version}"
+    )
+  fi
+  CROSS_ARGS+=(
+    --overlays "${CHROMIUMOS_OVERLAY} /usr/local/portage/stable"
+    --ov-output "${CROSSDEV_OVERLAY}"
+    --ex-gdb
+  )
+
+  sudo -E FEATURES="splitdebug ${FEATURES}" crossdev "${CROSS_ARGS[@]}"
+}
+
 # Get the version number of a toolchain package.
 cross_get_version() {
   local pkg="$1"
@@ -410,33 +543,62 @@ BOARD_OVERLAY_LIST=$(cros_overlay_list \
 
 eval $(portageq envvar -v CHOST PKGDIR)
 
-if [ -d "${BOARD_ROOT}" ] ; then
-  if [[ ${FLAGS_force} -eq ${FLAGS_TRUE} ]]; then
-    echo "--force set.  Re-creating ${BOARD_ROOT}..."
-    # Removal takes long. Make it asynchronous.
-    TEMP_DIR=`mktemp -d`
-    sudo mv "${BOARD_ROOT}" "${TEMP_DIR}"
-    sudo rm -rf "${TEMP_DIR}" &
-  else
-    if ! ${HOST_BOARD}; then
-      { print_board_make_conf; print_board_binhost_config; } | \
-        sudo_clobber $BOARD_ETC/make.conf.board
+# Update all the toolchains that this board wants.
+for toolchain in ${all_toolchains[@]} ; do
+  [[ "${CHOST}" == "${toolchain}" ]] && continue
+  info "Checking for updates to ${toolchain} ..."
+
+  toolchain_updated=${FLAGS_FALSE}
+  if toolchain_needs_update ${toolchain} ; then
+    toolchain_updated=${FLAGS_TRUE}
+
+    warn "Toolchain needs to be updated! Updating ${toolchain} ..."
+    uninstall_toolchain ${toolchain}
+    build_toolchain ${toolchain}
+
+    if [[ "${toolchain}" != arm* ]] ; then
+      info "Switching on gold as the default linker."
+      BINUTILS_VERSION=$(cross_get_version binutils ${toolchain} | \
+                         sed 's/-r[0-9]\+//g')
+      sudo binutils-config "${toolchain}-${BINUTILS_VERSION}-gold"
     fi
-    if [[ ${FLAGS_quiet} -eq ${FLAGS_FALSE} ]]; then
-      warn "Board output directory '$BOARD_ROOT' already exists."
-      warn "Not setting up board root. "
-      warn "Use --force to clobber the board root and start again."
-    fi
-    if board_needs_libc_update; then
+  fi
+
+  if [[ "${toolchain}" == "${FLAGS_toolchain}" ]] &&
+     [ -d "$BOARD_ROOT" ] && [ "$FLAGS_force" == "$FLAGS_FALSE" ] ; then
+    if [[ "${toolchain_updated}" == "${FLAGS_TRUE}" ]] ; then
+      # If the board root already exists, re-install the toolchain there.
+      install_toolchain_in_board
+    elif board_needs_libc_update; then
       # Update the users libc in their board if needed.
       echo "Updating libc in the board."
       install_toolchain_in_board
     fi
+  fi
+done
+
+if [ -d "$BOARD_ROOT" ] ; then
+  if [[ $FLAGS_force -eq $FLAGS_TRUE ]]; then
+    echo "--force set.  Re-creating $BOARD_ROOT..."
+    # Removal takes long. Make it asynchronous.
+    TEMP_DIR=`mktemp -d`
+    sudo mv $BOARD_ROOT $TEMP_DIR
+    sudo rm -rf $TEMP_DIR &
+  else
+    if ! $HOST_BOARD; then
+      { print_board_make_conf; print_board_binhost_config; } | \
+        sudo_clobber $BOARD_ETC/make.conf.board
+    fi
+    if [[ $FLAGS_quiet -eq $FLAGS_FALSE ]]; then
+      warn "Board output directory '$BOARD_ROOT' already exists."
+      warn "Not setting up board root. "
+      warn "Use --force to clobber the board root and start again."
+    fi
     exit 0
   fi
 fi
 
-sudo mkdir -p "${BOARD_ROOT}" "${BOARD_ETC}" "${BOARD_PROFILE}"
+sudo mkdir -p "$BOARD_ROOT" "${BOARD_ETC}" "${BOARD_PROFILE}"
 
 if [ "${CHOST}" != "$FLAGS_toolchain" ] ; then
   # TODO(cmasone): Do this more cleanly, if we figure out what "cleanly" means.
diff --git a/update_chroot b/update_chroot
index 265704342a..a1cf213887 100755
--- a/update_chroot
+++ b/update_chroot
@@ -29,8 +29,6 @@ show_help_if_requested "$@"
 DEFINE_boolean fast ${DEFAULT_FAST} "Call many emerges in parallel"
 DEFINE_integer jobs -1 \
   "How many packages to build in parallel at maximum."
-DEFINE_boolean skip_toolchain_update $FLAGS_FALSE \
-  "Don't update the toolchains."
 
 # Parse command line flags
 FLAGS "$@" || exit 1
@@ -82,14 +80,18 @@ fi
 
 # In first pass, update portage and toolchains. Lagged updates of both
 # can cause serious issues later.
-if [ "${FLAGS_skip_toolchain_update}" -eq "${FLAGS_FALSE}" ]; then
-  TOOLCHAIN_FLAGS=""
-  # This should really only be skipped while bootstrapping.
-  if [ "${FLAGS_usepkg}" -eq "${FLAGS_FALSE}" ]; then
-    TOOLCHAIN_FLAGS="--nousepkg"
-  fi
-  # Expand the path before sudo, as root doesn't have the same path magic.
-  sudo $(type -p cros_setup_toolchains) ${TOOLCHAIN_FLAGS}
+export CHOST="$(portageq envvar CHOST)"
+LATEST=$(gcc-config -l | awk -v chost="${CHOST}" '$2 ~ chost { print $2 }' | \
+         sort -V | tail -n 1)
+CURRENT="$(gcc-config -c)" || true # This fails if current profile is invalid.
+sudo -E ${EMERGE_CMD} ${EMERGE_FLAGS} \
+    sys-devel/gcc sys-devel/binutils sys-libs/glibc sys-apps/portage
+# If the latest toolchain wasn't already selected before we updated, do nothing,
+# otherwise autoselect the latest. Also fix if the current profile is invalid.
+if [ "${LATEST}" != "${CURRENT}" ] || ! gcc-config -c &> /dev/null; then
+  LATEST=$(gcc-config -l | awk -v chost="${CHOST}" '$2 ~ chost { print $2 }' | \
+           sort -V | tail -n 1 )
+  sudo -E gcc-config "${LATEST}"
 fi
 
 # Second pass, update everything else.