summary refs log tree commit diff
path: root/gnu/packages/commencement.scm
diff options
context:
space:
mode:
Diffstat (limited to 'gnu/packages/commencement.scm')
-rw-r--r--gnu/packages/commencement.scm3129
1 files changed, 2211 insertions, 918 deletions
diff --git a/gnu/packages/commencement.scm b/gnu/packages/commencement.scm
index 46b3859b6e..59ef5d078b 100644
--- a/gnu/packages/commencement.scm
+++ b/gnu/packages/commencement.scm
@@ -5,8 +5,9 @@
 ;;; Copyright © 2014, 2015, 2017 Mark H Weaver <mhw@netris.org>
 ;;; Copyright © 2017, 2018, 2019 Efraim Flashner <efraim@flashner.co.il>
 ;;; Copyright © 2018 Tobias Geerinckx-Rice <me@tobias.gr>
-;;; Copyright © 2018 Jan (janneke) Nieuwenhuizen <janneke@gnu.org>
-;;; Copyright © 2019 Marius Bakke <mbakke@fastmail.com>
+;;; Copyright © 2018, 2019, 2020 Jan (janneke) Nieuwenhuizen <janneke@gnu.org>
+;;; Copyright © 2019, 2020 Marius Bakke <mbakke@fastmail.com>
+;;; Copyright © 2020 Timothy Sample <samplet@ngyro.com>
 ;;;
 ;;; This file is part of GNU Guix.
 ;;;
@@ -31,7 +32,6 @@
   #:use-module (gnu packages c)
   #:use-module (gnu packages gcc)
   #:use-module (gnu packages m4)
-  #:use-module (gnu packages file)
   #:use-module (gnu packages gawk)
   #:use-module (gnu packages bison)
   #:use-module (gnu packages flex)
@@ -44,13 +44,16 @@
   #:use-module (gnu packages python)
   #:use-module (gnu packages linux)
   #:use-module (gnu packages hurd)
+  #:use-module (gnu packages shells)
   #:use-module (gnu packages texinfo)
   #:use-module (gnu packages pkg-config)
+  #:use-module (gnu packages rsync)
   #:use-module (gnu packages xml)
   #:use-module (guix packages)
   #:use-module (guix download)
   #:use-module (guix build-system gnu)
   #:use-module (guix build-system trivial)
+  #:use-module ((guix licenses) #:prefix license:)
   #:use-module (guix memoization)
   #:use-module (guix utils)
   #:use-module (srfi srfi-1)
@@ -80,81 +83,369 @@
 ;;;
 ;;; Code:
 
+(define bootar
+  (package
+    (name "bootar")
+    (version "1a")
+    (source (origin
+              (method url-fetch)
+              (uri (list (string-append
+                          "mirror://gnu/guix/mirror/bootar-" version ".ses")
+                         (string-append
+                          "https://files.ngyro.com/bootar/bootar-"
+                          version ".ses")))
+              (sha256
+               (base32
+                "0mvp6vgx0q316fvy3z2lddlc5xgq5np3bm1fypgvj6dnayibg9np"))))
+    (build-system gnu-build-system)
+    (arguments
+     `(#:implicit-inputs? #f
+       #:tests? #f
+       #:guile ,%bootstrap-guile
+       #:imported-modules ((guix build gnu-bootstrap)
+                           ,@%gnu-build-system-modules)
+       #:phases
+       (begin
+         (use-modules (guix build gnu-bootstrap))
+         (modify-phases %standard-phases
+           (replace 'unpack
+             (lambda* (#:key inputs #:allow-other-keys)
+               (let* ((source (assoc-ref inputs "source"))
+                      (guile-dir (assoc-ref inputs "guile"))
+                      (guile (string-append guile-dir "/bin/guile")))
+                 (invoke guile "--no-auto-compile" source)
+                 (chdir "bootar")
+                 #t)))
+           (replace 'configure (bootstrap-configure ,version "." "scripts"))
+           (replace 'build (bootstrap-build "."))
+           (replace 'install (bootstrap-install "." "scripts"))))))
+    (inputs `(("guile" ,%bootstrap-guile)))
+    (home-page "https://git.ngyro.com/bootar")
+    (synopsis "Tar decompression and extraction in Guile Scheme")
+    (description "Bootar is a simple Tar extractor written in Guile
+Scheme.  It supports running 'tar xvf' on uncompressed tarballs or
+tarballs that are compressed with BZip2, GZip, or XZ.  It also provides
+standalone scripts for 'bzip2', 'gzip', and 'xz' that each support
+decompression to standard output.
+
+What makes this special is that Bootar is distributed as a
+self-extracting Scheme (SES) program.  That is, a little script that
+outputs the source code of Bootar.  This makes it possible to go from
+pure Scheme to Tar and decompression in one easy step.")
+    (license license:gpl3+)))
+
+(define gash-boot
+  (package
+    (inherit gash)
+    (name "gash-boot")
+    (source (origin
+              (inherit (package-source gash))
+              (modules '())))
+    (arguments
+     `(#:implicit-inputs? #f
+       #:tests? #f
+       #:guile ,%bootstrap-guile
+       #:imported-modules ((guix build gnu-bootstrap)
+                           ,@%gnu-build-system-modules)
+       #:phases
+       (begin
+         (use-modules (guix build gnu-bootstrap))
+         (modify-phases %standard-phases
+           (replace 'configure
+             (bootstrap-configure ,(package-version gash) "gash" "scripts"))
+           (replace 'build (bootstrap-build "gash"))
+           (replace 'install (bootstrap-install "gash" "scripts"))
+           (add-after 'install 'install-symlinks
+             (lambda* (#:key outputs #:allow-other-keys)
+               (let ((out (assoc-ref outputs "out")))
+                 (symlink (string-append out "/bin/gash")
+                          (string-append out "/bin/sh"))
+                 (symlink (string-append out "/bin/gash")
+                          (string-append out "/bin/bash"))
+                 #t)))))))
+    (inputs `(("guile" ,%bootstrap-guile)))
+    (native-inputs `(("bootar" ,bootar)))))
+
+(define gash-utils-boot
+  (package
+    (inherit gash-utils)
+    (name "gash-utils-boot")
+    (arguments
+     `(#:implicit-inputs? #f
+       #:tests? #f
+       #:guile ,%bootstrap-guile
+       #:imported-modules ((guix build gnu-bootstrap)
+                           ,@%gnu-build-system-modules)
+       #:phases
+       (begin
+         (use-modules (guix build gnu-bootstrap))
+         (modify-phases %standard-phases
+           (add-after 'unpack 'set-load-path
+             (lambda* (#:key inputs #:allow-other-keys)
+               (let ((gash (assoc-ref inputs "gash")))
+                 (add-to-load-path (string-append gash "/share/guile/site/"
+                                                  (effective-version))))
+               #t))
+           (add-before 'configure 'pre-configure
+             (lambda _
+               (format #t "Creating gash/commands/testb.scm~%")
+               (copy-file "gash/commands/test.scm"
+                          "gash/commands/testb.scm")
+               (substitute* "gash/commands/testb.scm"
+                 (("gash commands test") "gash commands testb")
+                 (("apply test [(]cdr") "apply test/bracket (cdr"))
+               (for-each (lambda (script)
+                           (let ((target (string-append "scripts/"
+                                                        script ".in")))
+                             (format #t "Creating scripts/~a~%" target)
+                             (copy-file "scripts/template.in" target)
+                             (substitute* target
+                               (("@UTILITY@") script))))
+                         '("awk" "basename" "cat" "chmod" "cmp" "command"
+                           "compress" "cp" "cut" "diff" "dirname" "expr"
+                           "false" "find" "grep" "head" "ln" "ls" "mkdir"
+                           "mv" "printf" "pwd" "reboot" "rm" "rmdir"
+                           "sed" "sleep" "sort" "tar" "test" "touch" "tr"
+                           "true" "uname" "uniq" "wc" "which"))
+               (format #t "Creating scripts/[.in~%")
+               (copy-file "scripts/template.in" "scripts/[.in")
+               (substitute* "scripts/[.in"
+                 (("@UTILITY@") "testb"))
+               (delete-file "scripts/template.in")
+               #t))
+           (replace 'configure
+             (bootstrap-configure ,(package-version gash-utils)
+                                  "gash" "scripts"))
+           (replace 'build (bootstrap-build "gash"))
+           (replace 'install (bootstrap-install "gash" "scripts"))
+           ;; XXX: The scripts should add Gash to their load paths and
+           ;; this phase should not exist.
+           (add-after 'install 'copy-gash
+             (lambda* (#:key inputs outputs #:allow-other-keys)
+               (let* ((out (assoc-ref outputs "out"))
+                      (moddir (string-append out "/share/guile/site/"
+                                             (effective-version)))
+                      (godir (string-append out "/lib/guile/"
+                                            (effective-version)
+                                            "/site-ccache"))
+                      (gash (assoc-ref inputs "gash"))
+                      (gash-moddir (string-append gash "/share/guile/site/"
+                                                  (effective-version)))
+                      (gash-godir (string-append gash "/lib/guile/"
+                                                 (effective-version)
+                                                 "/site-ccache")))
+                 (copy-file (string-append gash-moddir "/gash/compat.scm")
+                            (string-append moddir "/gash/compat.scm"))
+                 (copy-recursively (string-append gash-moddir "/gash/compat")
+                                   (string-append moddir "/gash/compat"))
+                 (copy-file (string-append gash-godir "/gash/compat.go")
+                            (string-append godir "/gash/compat.go"))
+                 (copy-recursively (string-append gash-godir "/gash/compat")
+                                   (string-append godir "/gash/compat"))
+                 #t)))))))
+    (inputs `(("gash" ,gash-boot)
+              ("guile" ,%bootstrap-guile)))
+    (native-inputs `(("bootar" ,bootar)))))
+
+(define (%boot-gash-inputs)
+  `(("bash" , gash-boot)                ; gnu-build-system wants "bash"
+    ("coreutils" , gash-utils-boot)
+    ("bootar" ,bootar)
+    ("guile" ,%bootstrap-guile)))
+
+(define %bootstrap-mes-rewired
+  (package
+    (inherit mes)
+    (name "bootstrap-mes-rewired")
+    (version "0.19")
+    (source #f)
+    (native-inputs `(("mes" ,%bootstrap-mes)
+                     ("gash" ,gash-boot)))
+    (inputs '())
+    (propagated-inputs '())
+    (outputs '("out"))
+    (build-system trivial-build-system)
+    (arguments
+     `(#:guile ,%bootstrap-guile
+       #:modules ((guix build utils))
+
+       #:builder (begin
+                   (use-modules (guix build utils)
+                                (srfi srfi-26))
+
+                   (let* ((mes (assoc-ref %build-inputs "mes"))
+                          (gash (assoc-ref %build-inputs "gash"))
+                          (mes-bin (string-append mes "/bin"))
+                          (guile (string-append mes-bin "/mes"))
+                          (mes-module (string-append mes "/share/mes/module"))
+                          (out (assoc-ref %outputs "out"))
+                          (bin (string-append out "/bin"))
+                          (mescc (string-append bin "/mescc"))
+                          (module (string-append out "/share/mes/module")))
+                     (define (rewire file)
+                       (substitute* file
+                         ((mes) out)
+                         (("/gnu/store[^ ]+mes-minimal-[^/)}\"]*") out)
+                         (("/gnu/store[^ ]+guile-[^/]*/bin/guile") guile)
+                         (("/gnu/store[^ ]+bash-[^/)}\"]*") gash)))
+
+                     (mkdir-p bin)
+                     (for-each (lambda (file) (install-file file bin))
+                               (find-files mes-bin))
+                     (mkdir-p module)
+                     (copy-recursively (string-append mes-module "/mes")
+                                       (string-append module "/mes"))
+                     (copy-recursively (string-append mes-module "/srfi")
+                                       (string-append module "/srfi"))
+                     (for-each rewire
+                               ;; Cannot easily rewire "mes" because it
+                               ;; contains NUL characters; would require
+                               ;; remove-store-references alike trick
+                               (filter (negate (cut string-suffix? "/mes" <>))
+                                       (find-files bin)))
+                     (rewire (string-append module "/mes/boot-0.scm"))
+
+                     (delete-file mescc)
+                     (with-output-to-file mescc
+                       (lambda _
+                         (display (string-append
+                                   "\
+#! " gash "/bin/sh
+LANG=C
+LC_ALL=C
+export LANG LC_ALL
+
+MES_PREFIX=${MES_REWIRED_PREFIX-" out "/share/mes}
+MES=" bin "/mes
+export MES MES_PREFIX
+
+MES_ARENA=${MES_REWIRED_ARENA-10000000}
+MES_MAX_ARENA=${MES_REWIRED_ARENA-10000000}
+MES_STACK=${MES_REWIRED_STACK-1000000}
+export MES_ARENA MES_MAX_ARENA MES_STACK
+
+$MES -e '(mescc)' module/mescc.scm -- \"$@\"
+"))))
+                     (chmod mescc #o555)
+
+                     (with-directory-excursion module
+                       (chmod "mes/base.mes" #o644)
+                       (copy-file "mes/base.mes" "mes/base.mes.orig")
+                       (let ((base.mes (open-file "mes/base.mes" "a")))
+                         (display "
+;; A fixed map, from Mes 0.21, required to bootstrap Mes 0.21
+(define (map f h . t)
+  (if (or (null? h)
+          (and (pair? t) (null? (car t)))
+          (and (pair? t) (pair? (cdr t)) (null? (cadr t)))) '()
+      (if (null? t) (cons (f (car h)) (map f (cdr h)))
+          (if (null? (cdr t))
+              (cons (f (car h) (caar t)) (map f (cdr h) (cdar t)))
+              (if (null? (cddr t))
+                  (cons (f (car h) (caar t) (caadr t)) (map f (cdr h) (cdar t) (cdadr t)))
+                  (error 'unsupported (cons* 'map-4: f h t))b )))))
+" base.mes)
+                         (close base.mes))
+
+                       (chmod "mes/guile.mes" #o644)
+                       (copy-file "mes/guile.mes" "mes/guile.mes.orig")
+                       (let ((guile.mes (open-file "mes/guile.mes" "a")))
+                         (display "
+;; After booting guile.scm; use Mes 0.21; especially: MesCC 0.21
+(let* ((self (car (command-line)))
+       (prefix (dirname (dirname self))))
+  (set! %moduledir (string-append prefix \"/mes/module/\"))
+  (setenv \"%numbered_arch\" \"true\"))
+
+" guile.mes)
+                         (close guile.mes)))
+                     #t))))))
+
 (define mes-boot
   (package
     (inherit mes)
     (name "mes-boot")
-    (version "0.19")
+    (version "0.22")
     (source (origin
               (method url-fetch)
               (uri (string-append "mirror://gnu/mes/"
                                   "mes-" version ".tar.gz"))
               (sha256
                (base32
-                "15h4yhaywdc0djpjlin2jz1kzahpqxfki0r0aav1qm9nxxmnp1l0"))))
+                "0p1jsrrmcbc0zrvbvnjbb6iyxr0in71km293q8qj6gnar6bw09av"))))
     (inputs '())
     (propagated-inputs '())
     (native-inputs
-     `(("mescc-tools" ,%bootstrap-mescc-tools)
-       ("nyacc-source" ,(bootstrap-origin
-                         (package-source nyacc-0.86)))
-
-       ("coreutils" , %bootstrap-coreutils&co)
-       ("bootstrap-mes" ,%bootstrap-mes)))
+     `(("nyacc-source" ,(origin (inherit (package-source nyacc))
+                                (snippet #f)))
+       ("mes" ,%bootstrap-mes-rewired)
+       ("mescc-tools" ,%bootstrap-mescc-tools)
+       ,@(%boot-gash-inputs)))
     (arguments
      `(#:implicit-inputs? #f
+       #:tests? #f
        #:guile ,%bootstrap-guile
        #:strip-binaries? #f    ; binutil's strip b0rkes MesCC/M1/hex2 binaries
        #:phases
        (modify-phases %standard-phases
          (add-after 'unpack 'unpack-seeds
            (lambda _
-             (let ((nyacc-source (assoc-ref %build-inputs "nyacc-source"))
-                   (bootstrap-mes (assoc-ref %build-inputs "bootstrap-mes")))
+             (let ((nyacc-source (assoc-ref %build-inputs "nyacc-source")))
                (with-directory-excursion ".."
-                 (mkdir-p "nyacc-source")
-                 (invoke "tar" "--strip=1" "-C" "nyacc-source" "-xvf" nyacc-source)
-                 (symlink (string-append bootstrap-mes "/share/mes/lib") "mes-seed"))
-               #t)))
+                 (invoke "tar" "-xvf" nyacc-source)))))
          (replace 'configure
            (lambda* (#:key outputs #:allow-other-keys)
-             (let ((out (assoc-ref %outputs "out")))
-               (setenv "GUILE" "mes")
-               (setenv "GUILE_EFFECTIVE_VERSION" "2.2")
-               (setenv "GUILE_LOAD_PATH" "nyacc")
-               (symlink (string-append "../nyacc-source/module") "nyacc")
-               (invoke "bash" "configure.sh"
-                       (string-append "--prefix=" out)))))
+             (let ((out (assoc-ref %outputs "out"))
+                   (gash (assoc-ref %build-inputs "bash"))
+                   (mes (assoc-ref %build-inputs "mes"))
+                   (dir (with-directory-excursion ".." (getcwd))))
+               (setenv "AR" (string-append "gash " (getcwd) "/scripts/mesar"))
+               (setenv "BASH" (string-append gash "/bin/bash"))
+               (setenv "CC" (string-append mes "/bin/mescc"))
+               (setenv "GUILE_LOAD_PATH"
+                       (string-append
+                        mes "/share/mes/module"
+                        ":" dir "/nyacc-0.99.0/module"))
+               (invoke "gash" "configure.sh"
+                       (string-append "--prefix=" out)
+                       (string-append "--host=i686-linux-gnu")))))
          (replace 'build
            (lambda _
-             (let ((mes (assoc-ref %build-inputs "bootstrap-mes")))
-               (setenv "MES_PREFIX" (string-append mes "/share/mes"))
-               (setenv "MES_ARENA" "100000000")
-               (setenv "MES_MAX_ARENA" "100000000")
-               (setenv "MES_STACK" "10000000")
-               (invoke "sh" "bootstrap.sh"))))
-         (replace 'check
-           (lambda _
-             (setenv "DIFF" "sh scripts/diff.scm")
-             ;; fail fast tests
-             ;; (invoke "sh" "-x" "build-aux/test.sh" "scaffold/tests/t")
-             ;; (invoke "sh" "-x" "build-aux/test.sh" "scaffold/tests/63-struct-cell")
-             (invoke "sh" "check.sh")))
+             (invoke "sh" "bootstrap.sh")))
+         (delete 'check)
          (replace 'install
            (lambda _
-             (invoke "sh" "install.sh"))))))
+             (substitute* "install.sh"  ; show some progress
+               ((" -xf") " -xvf")
+               (("^( *)((cp|mkdir|tar) [^']*[^\\])\n" all space cmd)
+                (string-append space "echo '" cmd "'\n"
+                               space cmd "\n")))
+             (invoke "sh" "install.sh")
+             ;; Keep ASCII output, for friendlier comparison and bisection
+             (let* ((out (assoc-ref %outputs "out"))
+                    (cache (string-append out "/lib/cache")))
+               (define (objects-in-dir dir)
+                 (find-files dir
+                             (lambda (name stat)
+                               (and (equal? (dirname name) dir)
+                                    (or (string-suffix? ".o" name)
+                                        (string-suffix? ".s" name))))))
+               (for-each (lambda (x) (install-file x cache))
+                         (append (objects-in-dir ".")
+                                 (objects-in-dir "mescc-lib"))))
+             #t)))))
     (native-search-paths
-     ;; Use the language-specific variables rather than 'CPATH' because they
-     ;; are equivalent to '-isystem' whereas 'CPATH' is equivalent to '-I'.
-     ;; The intent is to allow headers that are in the search path to be
-     ;; treated as "system headers" (headers exempt from warnings) just like
-     ;; the typical /usr/include headers on an FHS system.
      (list (search-path-specification
             (variable "C_INCLUDE_PATH")
-            (files '("share/mes/include")))
+            (files '("include")))
            (search-path-specification
             (variable "LIBRARY_PATH")
-            (files '("share/mes/lib")))))))
+            (files '("lib")))
+           (search-path-specification
+            (variable "MES_PREFIX")
+            (separator #f)
+            (files '("")))))))
+
 
 (define tcc-boot0
   ;; Pristine tcc cannot be built by MesCC, we are keeping a delta of 11
@@ -163,266 +454,467 @@
   ;; bootstrappable effort; we will try again later.  These patches have been
   ;; ported to 0.9.27, alas the resulting tcc is buggy.  Once MesCC is more
   ;; mature, this package should use the 0.9.27 sources (or later).
-  (let ((version "0.9.26")
-        (revision "6")
-        (commit "c004e9a34fb026bb44d211ab98bb768e79900eef"))
-    (package
-      (inherit tcc)
-      (name "tcc-boot0")
-      (version (string-append version "-" revision "." (string-take commit 7)))
-      (source (origin
-                (method url-fetch)
-                (uri (list (string-append "mirror://gnu/guix/mirror"
-                                          "/tinycc-" commit ".tar.gz")
-                           (string-append "https://gitlab.com/janneke/tinycc"
-                                          "/-/archive/" commit
-                                          "/tinycc-" commit ".tar.gz")))
-                (sha256
-                 (base32
-                  "1hmzn1pq0x22ppd80hyrn5qzqq94mxd0ychzj6vrr2vnj2frjv5b"))))
-      (build-system gnu-build-system)
-      (supported-systems '("i686-linux" "x86_64-linux"))
-      (inputs '())
-      (propagated-inputs '())
-      (native-inputs
-       `(("mes" ,mes-boot)
-         ("mescc-tools" ,%bootstrap-mescc-tools)
-         ("nyacc-source" ,(bootstrap-origin
-                           (package-source nyacc-0.86)))
-
-         ("coreutils" , %bootstrap-coreutils&co)
-         ("bootstrap-mes" ,%bootstrap-mes)))
-      (arguments
-       `(#:implicit-inputs? #f
-         #:guile ,%bootstrap-guile
-         #:strip-binaries? #f  ; binutil's strip b0rkes MesCC/M1/hex2 binaries
-         #:phases
-         (modify-phases %standard-phases
-           (add-after 'unpack 'unpack-seeds
-             (lambda* (#:key outputs #:allow-other-keys)
-               (let* ((coreutils (assoc-ref %build-inputs "coreutils"))
-                      (nyacc-source (assoc-ref %build-inputs "nyacc-source"))
-                      (bootstrap-mes (assoc-ref %build-inputs "bootstrap-mes")))
-                 (setenv "PATH" (string-append
-                                 coreutils "/bin"))
-                 (format (current-error-port) "PATH=~s\n" (getenv "PATH"))
-                 (with-directory-excursion ".."
-                   (mkdir-p "nyacc-source")
-                   (invoke "tar" "--strip=1" "-C" "nyacc-source"
-                           "-xvf" nyacc-source)
-                   (symlink (string-append bootstrap-mes "/share/mes/lib") "mes-seed"))
-                 #t)))
-           (replace 'configure
-             (lambda* (#:key outputs #:allow-other-keys)
-               (let* ((out (assoc-ref %outputs "out"))
-                      (dir (with-directory-excursion ".." (getcwd)))
-                      (coreutils (assoc-ref %build-inputs "coreutils"))
-                      (mes (assoc-ref %build-inputs "mes"))
-                      (mescc-tools (assoc-ref %build-inputs "mescc-tools"))
-                      (libc (assoc-ref %build-inputs "libc"))
-                      (interpreter (if libc
-                                       ;; also for x86_64-linux, we are still on i686-linux
-                                       (string-append libc ,(glibc-dynamic-linker "i686-linux"))
-                                       (string-append mes "/lib/mes-loader"))))
-                 (setenv "PATH" (string-append
-                                 coreutils "/bin"
-                                 ":" mes "/bin"
-                                 ":" mescc-tools "/bin"))
-                 (format (current-error-port) "PATH=~s\n" (getenv "PATH"))
-
-                 (setenv "PREFIX" out)
-                 (symlink (string-append mes "/share/mes") "mes")
-                 (symlink (string-append "../nyacc-source/module") "nyacc")
-                 (setenv "MES_PREFIX" "mes")
-                 (setenv "MES_ARENA" "100000000")
-                 (setenv "MES_MAX_ARENA" "100000000")
-                 (setenv "MES_STACK" "10000000")
-                 (setenv "MES" "mes")
-                 (setenv "GUILE_LOAD_PATH" "nyacc")
-                 (invoke "sh" "configure"
-                         "--prefix=$PREFIX"
-                         (string-append "--elfinterp=" interpreter)
-                         "--crtprefix=."
-                         "--tccdir=."))))
-           (replace 'build
-             (lambda _
-               (substitute* "bootstrap.sh"
-                 (("^    cmp") "#    cmp"))
-               (invoke "sh" "bootstrap.sh")))
-           (replace 'check
-             (lambda _
-               (setenv "DIFF" "diff.scm")
-               (setenv "OBJDUMP" "true")
-               ;; fail fast tests
-               ;; (invoke "sh" "test.sh" "mes/scaffold/tests/30-strlen")
-               ;; (invoke "sh" "-x" "test.sh" "mes/scaffold/tinycc/00_assignment")
-               (setenv "TCC" "./tcc")
-               (invoke "sh" "check.sh")))
-           (replace 'install
-             (lambda _
-               (invoke "sh" "install.sh"))))))
-      (native-search-paths
-       ;; Use the language-specific variables rather than 'CPATH' because they
-       ;; are equivalent to '-isystem' whereas 'CPATH' is equivalent to '-I'.
-       ;; The intent is to allow headers that are in the search path to be
-       ;; treated as "system headers" (headers exempt from warnings) just like
-       ;; the typical /usr/include headers on an FHS system.
-       (list (search-path-specification
-              (variable "C_INCLUDE_PATH")
-              (files '("include")))
-             (search-path-specification
-              (variable "LIBRARY_PATH")
-              (files '("lib"))))))))
-
-(define tcc-boot
   (package
-    (inherit tcc-boot0)
-    (name "tcc-boot")
-    (version "0.9.27")
-    (source (bootstrap-origin
-             (origin
-               (inherit (package-source tcc))
-               (patches (search-patches "tcc-boot-0.9.27.patch")))))
+    (inherit tcc)
+    (name "tcc-boot0")
+    (version "0.9.26-1103-g6e62e0e")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append
+                    "http://lilypond.org/janneke/mes/20191117/"
+                    "/tcc-" version ".tar.gz"))
+              (sha256
+               (base32
+                "1qbybw7mxbgkv3sazvz1v7c8byq998vk8f1h25ik8w3d2l63lxng"))))
     (build-system gnu-build-system)
+    (supported-systems '("i686-linux" "x86_64-linux"))
     (inputs '())
     (propagated-inputs '())
     (native-inputs
      `(("mes" ,mes-boot)
-       ("tcc" ,tcc-boot0)
-
-       ("coreutils" , %bootstrap-coreutils&co)))
+       ("nyacc-source" ,(origin (inherit (package-source nyacc))
+                                (snippet #f)))
+       ("mescc-tools" ,%bootstrap-mescc-tools)
+       ,@(%boot-gash-inputs)))
     (arguments
      `(#:implicit-inputs? #f
        #:guile ,%bootstrap-guile
-
-       ;; Binutils' 'strip' b0rkes MesCC/M1/hex2 binaries, tcc-boot also comes
-       ;; with MesCC/M1/hex2-built binaries.
-       #:strip-binaries? #f
-
+       #:validate-runpath? #f           ; no dynamic executables
+       #:strip-binaries? #f             ; no strip yet
        #:phases
        (modify-phases %standard-phases
+         (add-after 'unpack 'unpack-seeds
+           (lambda* (#:key outputs #:allow-other-keys)
+             (let ((nyacc-source (assoc-ref %build-inputs "nyacc-source")))
+               (with-directory-excursion ".."
+                 (invoke "tar" "-xvf" nyacc-source)))))
          (replace 'configure
            (lambda* (#:key outputs #:allow-other-keys)
              (let* ((out (assoc-ref %outputs "out"))
-                    (coreutils (assoc-ref %build-inputs "coreutils"))
-                    (mes (assoc-ref %build-inputs "mes"))
-                    (tcc (assoc-ref %build-inputs "tcc"))
-                    (libc (assoc-ref %build-inputs "libc"))
-                    (interpreter (if libc
-                                     ;; also for x86_64-linux, we are still on i686-linux
-                                     (string-append libc ,(glibc-dynamic-linker "i686-linux"))
-                                     (string-append mes "/lib/mes-loader"))))
-               ;; unpack
-               (setenv "PATH" (string-append
-                               coreutils "/bin"
-                               ":" tcc "/bin"))
-               (format (current-error-port) "PATH=~s\n" (getenv "PATH"))
+                    (dir (with-directory-excursion ".." (getcwd)))
+                    (interpreter "/lib/mes-loader"))
+
+               (setenv "prefix" out)
+               (setenv "GUILE_LOAD_PATH"
+                       (string-append dir "/nyacc-0.99.0/module"))
+
+               (substitute* "conftest.c"
+                 (("volatile") ""))
+
                (invoke "sh" "configure"
-                       (string-append "--cc=tcc")
-                       (string-append "--cpu=i386")
+                       "--cc=mescc"
                        (string-append "--prefix=" out)
                        (string-append "--elfinterp=" interpreter)
-                       (string-append "--crtprefix=" tcc "/lib")
-                       (string-append "--sysincludepaths=" tcc "/include")
-                       (string-append "--libpaths=" tcc "/lib")))))
+                       "--crtprefix=."
+                       "--tccdir=."))))
          (replace 'build
-           (lambda* (#:key outputs #:allow-other-keys)
-             (let* ((out (assoc-ref %outputs "out"))
-                    (mes (assoc-ref %build-inputs "mes"))
-                    (tcc (assoc-ref %build-inputs "tcc"))
-                    (libc (assoc-ref %build-inputs "libc"))
-                    (interpreter (if libc
-                                     ;; also for x86_64-linux, we are still on i686-linux
-                                     (string-append libc ,(glibc-dynamic-linker "i686-linux"))
-                                     (string-append mes "/lib/mes-loader"))))
-               (invoke "tcc"
-                       "-vvv"
-                       "-D" "BOOTSTRAP=1"
-                       "-D" "ONE_SOURCE=1"
-                       "-D" "TCC_TARGET_I386=1"
-                       "-D" "CONFIG_TCC_STATIC=1"
-                       "-D" "CONFIG_USE_LIBGCC=1"
-                       "-D" (string-append "CONFIG_TCCDIR=\"" out "/lib/tcc\"")
-                       "-D" (string-append "CONFIG_TCC_CRTPREFIX=\"" out "/lib:{B}/lib:.\"")
-                       "-D" (string-append "CONFIG_TCC_CRTPREFIX=\"" out
-                                           "/lib:{B}/lib:.\"")
-                       "-D" (string-append "CONFIG_TCC_ELFINTERP=\"" interpreter "\"")
-                       "-D" (string-append "CONFIG_TCC_LIBPATHS=\"" tcc "/lib:{B}/lib:.\"")
-                       "-D" (string-append "CONFIG_TCC_SYSINCLUDEPATHS=\"" tcc "/include" ":/include:{B}/include\"")
-                       "-D" (string-append "TCC_LIBGCC=\"" tcc "/lib/libc.a\"")
-                       "-o" "tcc"
-                       "tcc.c"))))
+           (lambda _
+             (substitute* "bootstrap.sh" ; Show some progress
+               (("^( *)((cp|ls|mkdir|rm|[.]/tcc|[.]/[$][{PROGRAM_PREFIX[}]tcc) [^\"]*[^\\])\n" all space cmd)
+                (string-append space "echo \"" cmd "\"\n"
+                               space cmd "\n")))
+             (invoke "sh" "bootstrap.sh")))
          (replace 'check
            (lambda _
-             ;; FIXME: add sensible check target (without depending on make)
-             ;; ./check.sh ?
-             (= 1 (status:exit-val (system* "./tcc" "--help")))))
+             ;; fail fast tests
+             (system* "./tcc" "--help") ; --help exits 1
+             ;; (invoke "sh" "test.sh" "mes/scaffold/tests/30-strlen")
+             ;; (invoke "sh" "-x" "test.sh" "mes/scaffold/tinycc/00_assignment")
+             ;; TODO: add sensible check target (without depending on make)
+             ;; (invoke "sh" "check.sh")
+             #t))
          (replace 'install
-           (lambda* (#:key outputs #:allow-other-keys)
-             (let ((out (assoc-ref %outputs "out"))
-                   (tcc (assoc-ref %build-inputs "tcc")))
-               (mkdir-p (string-append out "/bin"))
-               (copy-file "tcc" (string-append out "/bin/tcc"))
-               (mkdir-p (string-append out "/lib/tcc"))
-               (copy-recursively (string-append tcc "/include")
-                                 (string-append out "/include"))
-               (copy-recursively (string-append tcc "/lib")
-                                 (string-append out "/lib"))
-               (invoke "tcc" "-D" "TCC_TARGET_I386=1" "-c" "-o" "libtcc1.o" "lib/libtcc1.c")
-               (invoke "tcc" "-ar" "rc" "libtcc1.a" "libtcc1.o")
-               (copy-file "libtcc1.a" (string-append out "/lib/libtcc1.a"))
-               (delete-file (string-append out "/lib/tcc/libtcc1.a"))
-               (copy-file "libtcc1.a" (string-append out "/lib/tcc/libtcc1.a"))
-               #t))))))))
+           (lambda _
+             (substitute* "install.sh"  ; Show some progress
+               (("^( *)((cp|ls|mkdir|rm|tar|./[$][{PROGRAM_PREFIX[}]tcc) [^\"]*[^\\])\n" all space cmd)
+                (string-append space "echo \"" cmd "\"\n"
+                               space cmd "\n")))
 
-(define make-mesboot0
+             (invoke "sh" "install.sh"))))))
+    (native-search-paths
+     (list (search-path-specification
+            (variable "C_INCLUDE_PATH")
+            (files '("include")))
+           (search-path-specification
+            (variable "LIBRARY_PATH")
+            (files '("lib")))))))
+
+(define gzip-mesboot
+  ;; The initial gzip.  We keep this scripted gzip build before building make
+  ;; to soften the dependency on Gash Core Utils gzip.
+  (package
+    (inherit gzip)
+    (version "1.2.4")
+    (name "gzip-mesboot")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "mirror://gnu/gzip/gzip-" version ".tar"))
+              (sha256
+               (base32
+                "1rhgk2vvmdvnn6vygf0dja92ryyng00knl0kz5srb77k2kryjb2d"))))
+    (supported-systems '("i686-linux" "x86_64-linux"))
+    (inputs '())
+    (propagated-inputs '())
+    (native-inputs `(("tcc" ,tcc-boot0)
+                     ,@(%boot-gash-inputs)))
+    (arguments
+     `(#:implicit-inputs? #f
+       #:guile ,%bootstrap-guile
+       #:strip-binaries? #f             ; no strip yet
+       #:phases
+       (modify-phases %standard-phases
+         (delete 'configure)
+         (add-after 'unpack 'scripted-patch
+           (lambda _
+             (substitute* "util.c"
+               (("^char [*]strlwr" all) (string-append all "_tcc_cannot_handle_dupe")))
+             #t))
+         (replace 'build
+           (lambda _
+             (let ((files '("bits" "crypt" "deflate" "getopt" "gzip"
+                            "inflate" "lzw" "trees" "unlzh" "unlzw"
+                            "unpack" "unzip" "util" "zip")))
+               (define (compile x)
+                 (invoke "tcc" "-c" "-D NO_UTIME=1" "-D HAVE_UNISTD_H=1"
+                         (string-append x ".c")))
+               (for-each compile files)
+               (apply invoke
+                      (cons* "tcc" "-o" "gzip"
+                             (map (lambda (x) (string-append x ".o")) files)))
+               (link "gzip" "gunzip"))))
+         (replace 'install
+           (lambda _
+             (let* ((out (assoc-ref %outputs "out"))
+                    (bin (string-append out "/bin")))
+               (install-file "gzip" bin)
+               (install-file "gunzip" bin))))
+         (replace 'check
+           (lambda _
+             (invoke "./gzip" "--version")))
+         ;; no gzip yet
+         (delete 'compress-documentation))))))
+
+(define gnu-make-mesboot0
+  ;; The initial make
   (package
     (inherit gnu-make)
     (name "make-mesboot0")
     (version "3.80")
     (source (origin
               (method url-fetch)
-              (uri (string-append "mirror://gnu/make/make-"
-                                  version ".tar.gz"))
+              (uri (string-append "mirror://gnu/make/make-" version ".tar.gz"))
               (sha256
                (base32
                 "1pb7fb7fqf9wz9najm85qdma1xhxzf1rhj5gwrlzdsz2zm0hpcv4"))))
     (supported-systems '("i686-linux" "x86_64-linux"))
     (inputs '())
     (propagated-inputs '())
-    (native-inputs `(("tcc" ,tcc-boot)
-
-                     ("bash" ,%bootstrap-coreutils&co)
-                     ("coreutils" ,%bootstrap-coreutils&co)))
+    (native-inputs `(("tcc" ,tcc-boot0)
+                     ,@(%boot-gash-inputs)))
     (arguments
      `(#:implicit-inputs? #f
-       #:tests? #f                                ; check depends on perl
        #:guile ,%bootstrap-guile
-       #:configure-flags `("CC=tcc -DO_RDONLY=0"
+       #:configure-flags '("CC=tcc"
+                           "CPP=tcc -E"
                            "LD=tcc"
+                           "--build=i686-unknown-linux-gnu"
+                           "--host=i686-unknown-linux-gnu"
                            "--disable-nls")
+       #:modules ((guix build gnu-build-system)
+                  (guix build utils)
+                  (srfi srfi-1))
+       #:strip-binaries? #f             ; no strip yet
        #:phases
        (modify-phases %standard-phases
+         (add-after 'unpack 'scripted-patch
+           (lambda _
+             (substitute* "build.sh.in"
+               (("@LIBOBJS@") "getloadavg.o")
+               (("@REMOTE@") "stub"))
+             #t))
          (add-after 'configure 'configure-fixup
            (lambda _
-             (substitute* "build.sh"
-               (("^REMOTE=.*") "REMOTE=stub\n")
-               (("^extras=.*") "extras=getloadavg.c\n"))
              (substitute* "make.h"
                (("^extern long int lseek.*" all) (string-append "// " all)))
              #t))
-         (delete 'patch-generated-file-shebangs)  ; no perl
          (replace 'build
            (lambda _
              (invoke "sh" "./build.sh")))
+         (replace 'check                ; proper check needs awk
+           (lambda _
+             (invoke "./make" "--version")))
          (replace 'install
-           (lambda* (#:key outputs #:allow-other-keys)
-             (let* ((out (assoc-ref outputs "out"))
+           (lambda _
+             (let* ((out (assoc-ref %outputs "out"))
                     (bin (string-append out "/bin")))
-               (install-file "make" bin)
+               (install-file "make" bin)))))))))
+
+(define (%boot-tcc0-inputs)
+  `(("make" ,gnu-make-mesboot0)
+    ("tcc" ,tcc-boot0)
+    ,@(%boot-gash-inputs)))
+
+(define bzip2-mesboot
+  ;; The initial bzip2
+  (package
+    (inherit bzip2)
+    (name "bzip2-mesboot")
+    (version (package-version bzip2))
+    (source (bootstrap-origin (package-source bzip2)))
+    (supported-systems '("i686-linux" "x86_64-linux"))
+    (inputs '())
+    (propagated-inputs '())
+    (native-inputs (%boot-tcc0-inputs))
+    (outputs '("out"))
+    (arguments
+     `(#:implicit-inputs? #f
+       #:guile ,%bootstrap-guile
+       #:parallel-build? #f
+       #:tests? #f            ; check is naive, also checks non-built PROGRAMS
+       #:strip-binaries? #f   ; no strip yet
+       #:make-flags (list "CC=tcc -I ." "AR=tcc -ar" "bzip2"
+                          (string-append "PREFIX="
+                                         (assoc-ref %outputs "out")))
+       #:phases
+       (modify-phases %standard-phases
+         (add-after 'unpack 'scripted-patch
+           (lambda _
+             (substitute* "Makefile"
+               (("\tln " all)
+                (string-append "\t#" all)))
+             (substitute* "bzip2.c"
+               (("struct utimbuf uTimBuf;" all)
+                (string-append "// " all))
+               (("uTimBuf[.]" all)
+                (string-append "// " all))
+               (("retVal = utime [(] dstName, &uTimBuf [)];" all)
+                (string-append "retVal = 0; // " all)))
+             #t))
+         (replace 'configure
+           (lambda _
+             (with-output-to-file "utime.h"
+               (lambda _ (display "
+#define fchown(filedes, owner, group) 0
+#define fchmod(filedes, mode) 0
+")))
+             #t))
+         (replace 'check
+           (lambda _
+             (invoke "./bzip2" "--help")))
+         ;; FIXME: no compressing gzip yet
+         (delete 'compress-documentation))))))
+
+(define bash-mesboot0
+  ;; The initial Bash
+  (package
+    (inherit static-bash)
+    (name "bash-mesboot0")
+    (version "2.05b")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "mirror://gnu/bash/bash-"
+                                  version ".tar.gz"))
+              (sha256
+               (base32
+                "1r1z2qdw3rz668nxrzwa14vk2zcn00hw7mpjn384picck49d80xs"))))
+    (inputs '())
+    (propagated-inputs '())
+    (native-inputs (%boot-tcc0-inputs))
+    (outputs '("out"))
+    (arguments
+     `(#:implicit-inputs? #f
+       #:guile ,%bootstrap-guile
+       #:parallel-build? #f
+       #:strip-binaries? #f             ; no strip yet
+       #:configure-flags
+       (list "--build=i686-unknown-linux-gnu"
+             "--host=i686-unknown-linux-gnu"
+
+             "--without-bash-malloc"
+             "--disable-readline"
+             "--disable-history"
+             "--disable-help-builtin"
+             "--disable-progcomp"
+             "--disable-net-redirections"
+             "--disable-nls"
+
+             ;; Pretend 'dlopen' is missing so we don't build loadable
+             ;; modules and related code.
+             "ac_cv_func_dlopen=no")
+       #:make-flags '("bash")
+       #:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'setenv
+           (lambda _
+             (let* ((gash (assoc-ref %build-inputs "bash"))
+                    (shell (string-append gash "/bin/gash")))
+               (setenv "CONFIG_SHELL" shell)
+               (setenv "SHELL" shell)
+               (setenv "CC" "tcc")
+               (setenv "LD" "tcc")
+               (setenv "AR" "tcc -ar")
+               (setenv "CFLAGS" "-D _POSIX_VERSION=1")
+               #t)))
+         (add-after 'unpack 'scripted-patch
+           (lambda _
+             (substitute* "Makefile.in"
+               (("mksyntax\\.c\n") "mksyntax.c -lgetopt\n")
+               (("buildversion[.]o\n") "buildversion.o -lgetopt\n")
+               ;; No size in Gash
+               (("\tsize ") "#\tsize"))
+             (substitute* "lib/sh/oslib.c"
+               (("int name, namelen;") "char *name; int namelen;"))
+             (substitute* "lib/sh/snprintf.c"
+               (("^#if (defined [(]HAVE_LOCALE_H[)])" all define) (string-append "#if 0 //" define)))
+             (substitute* "configure"
+               ((" egrep") " grep"))
+             #t))
+         (replace 'configure
+           (lambda* (#:key configure-flags #:allow-other-keys)
+             (let ((configure-flags (filter (lambda (x)
+                                              (and (not (string-prefix? "CONFIG_SHELL=" x))
+                                                   (not (string-prefix? "SHELL=" x))))
+                                            configure-flags)))
+               (format (current-error-port)
+                       "running ./configure ~a\n" (string-join configure-flags)))
+             (apply invoke (cons "./configure" configure-flags))))
+         (add-after 'configure 'configure-fixups
+           (lambda _
+             (substitute* "config.h"
+               (("#define GETCWD_BROKEN 1") "#undef GETCWD_BROKEN"))
+             (let ((config.h (open-file "config.h" "a")))
+               (display (string-append "
+// tcc: error: undefined symbol 'enable_hostname_completion'
+#define enable_hostname_completion(on_or_off) 0
+
+// /gnu/store/cq0cmv35s9dhilx14zaghlc08gpc0hwr-tcc-boot0-0.9.26-6.c004e9a/lib/libc.a: error: 'sigprocmask' defined twice
+#define HAVE_POSIX_SIGNALS 1
+#define endpwent(x) 0
+")
+                        config.h)
+               (close config.h))
+             #t))
+         (replace 'check
+           (lambda _
+             (invoke "./bash" "--version")))
+         (replace 'install
+           (lambda _
+             (let* ((out (assoc-ref %outputs "out"))
+                    (bin (string-append out "/bin")))
+               (mkdir-p bin)
+               (copy-file "bash" (string-append bin "/bash"))
+               (copy-file "bash" (string-append bin "/sh"))
                #t))))))))
 
+(define tcc-boot
+  ;; The final tcc.
+  (package
+    (inherit tcc-boot0)
+    (name "tcc-boot")
+    (version "0.9.27")
+    (source (origin
+              (inherit (package-source tcc))
+              ;; `patches' needs XZ
+              ;; (patches (search-patches "tcc-boot-0.9.27.patch"))
+              ))
+    (build-system gnu-build-system)
+    (inputs '())
+    (propagated-inputs '())
+    (native-inputs `(;;("boot-patch" ,(search-patch "tcc-boot-0.9.27.patch"))
+                     ("bzip2" ,bzip2-mesboot)
+                     ,@(%boot-tcc0-inputs)))
+    (arguments
+     `(#:implicit-inputs? #f
+       #:guile ,%bootstrap-guile
+       #:validate-runpath? #f           ; no dynamic executables
+       #:strip-binaries? #f             ; no strip yet
+       #:phases
+       (modify-phases %standard-phases
+         ;; tar xvf ..bz2 gives
+         ;; bzip2: PANIC -- internal consistency error
+         (replace 'unpack
+           (lambda* (#:key source #:allow-other-keys)
+             (copy-file source "tarball.tar.bz2")
+             (invoke "bzip2" "-d" "tarball.tar.bz2")
+             (invoke "tar" "xvf" "tarball.tar")
+             (chdir (string-append "tcc-" ,version))
+             #t))
+         ;; no patch yet
+         ;; (add-after 'unpack 'apply-boot-patch
+         ;;   (lambda* (#:key inputs #:allow-other-keys)
+         ;;     (let ((patch-file (assoc-ref inputs "boot-patch")))
+         ;;       (invoke "patch" "-p1" "-i" patch-file))))
+         (add-after 'unpack 'scripted-patch
+           (lambda* (#:key inputs #:allow-other-keys)
+             (substitute* "libtcc.c"
+               (("s->alacarte_link = 1;" all)
+                (string-append all "
+    s->static_link = 1;")))
+             #t))
+         (replace 'configure
+           (lambda* (#:key outputs #:allow-other-keys)
+             (let* ((out (assoc-ref %outputs "out"))
+                    (tcc (assoc-ref %build-inputs "tcc"))
+                    (libc (assoc-ref %build-inputs "libc"))
+                    (interpreter "/mes/loader"))
+               (invoke "sh" "configure"
+                       (string-append "--cc=tcc")
+                       (string-append "--cpu=i386")
+                       (string-append "--prefix=" out)
+                       (string-append "--elfinterp=" interpreter)
+                       (string-append "--crtprefix=" tcc "/lib")
+                       (string-append "--sysincludepaths=" tcc "/include")
+                       (string-append "--libpaths=" tcc "/lib")))))
+         (replace 'build
+           (lambda* (#:key outputs #:allow-other-keys)
+             (let* ((out (assoc-ref %outputs "out"))
+                    (tcc (assoc-ref %build-inputs "tcc"))
+                    (libc (assoc-ref %build-inputs "libc"))
+                    (interpreter "/mes/loader"))
+               (invoke
+                "tcc"
+                "-vvv"
+                "-D" "BOOTSTRAP=1"
+                "-D" "ONE_SOURCE=1"
+                "-D" "TCC_TARGET_I386=1"
+                "-D" "CONFIG_TCC_STATIC=1"
+                "-D" "CONFIG_USE_LIBGCC=1"
+                "-D" (string-append "CONFIG_TCCDIR=\"" out "/lib/tcc\"")
+                "-D" (string-append "CONFIG_TCC_CRTPREFIX=\"" out "/lib:{B}/lib:.\"")
+                "-D" (string-append "CONFIG_TCC_CRTPREFIX=\"" out "/lib:{B}/lib:.\"")
+                "-D" (string-append "CONFIG_TCC_ELFINTERP=\"" interpreter "\"")
+                "-D" (string-append "CONFIG_TCC_LIBPATHS=\"" tcc "/lib:{B}/lib:.\"")
+                "-D" (string-append "CONFIG_TCC_SYSINCLUDEPATHS=\""
+                                    tcc "/include" ":/include:{B}/include\"")
+                "-D" (string-append "TCC_LIBGCC=\"" tcc "/lib/libc.a\"")
+                "-o" "tcc"
+                "tcc.c"))))
+         (replace 'check
+           (lambda _
+             ;; FIXME: add sensible check target (without depending on make)
+             ;; ./check.sh ?
+             (= 1 (status:exit-val (system* "./tcc" "--help")))))
+         (replace 'install
+           (lambda* (#:key outputs #:allow-other-keys)
+             (let ((out (assoc-ref %outputs "out"))
+                   (tcc (assoc-ref %build-inputs "tcc")))
+               (and
+                (mkdir-p (string-append out "/bin"))
+                (copy-file "tcc" (string-append out "/bin/tcc"))
+                (mkdir-p (string-append out "/lib/tcc"))
+                (copy-recursively (string-append tcc "/include")
+                                  (string-append out "/include"))
+                (copy-recursively (string-append tcc "/lib")
+                                  (string-append out "/lib"))
+                (invoke "tcc" "-D" "TCC_TARGET_I386=1" "-c" "-o" "libtcc1.o" "lib/libtcc1.c")
+                (invoke "tcc" "-ar" "rc" "libtcc1.a" "libtcc1.o")
+                (copy-file "libtcc1.a" (string-append out "/lib/libtcc1.a"))
+                (delete-file (string-append out "/lib/tcc/libtcc1.a"))
+                (copy-file "libtcc1.a" (string-append out "/lib/tcc/libtcc1.a"))
+                #t)))))))))
+
 (define diffutils-mesboot
+  ;; The initial diffutils.
   (package
     (inherit diffutils)
     (name "diffutils-mesboot")
@@ -437,12 +929,7 @@
     (supported-systems '("i686-linux" "x86_64-linux"))
     (inputs '())
     (propagated-inputs '())
-    (native-inputs `(("mes" ,mes-boot)
-                     ("tcc" ,tcc-boot)
-
-                     ("bash" ,%bootstrap-coreutils&co)
-                     ("coreutils" ,%bootstrap-coreutils&co)
-                     ("make" ,make-mesboot0)))
+    (native-inputs (%boot-tcc0-inputs))
     (arguments
      `(#:implicit-inputs? #f
        #:guile ,%bootstrap-guile
@@ -451,97 +938,207 @@
        #:strip-binaries? #f   ; no strip yet
        #:phases
        (modify-phases %standard-phases
-         ;; diffutils-2.7 needs more traditional configure
-         (replace 'configure
-           (lambda* (#:key outputs #:allow-other-keys)
-             (let ((out (assoc-ref outputs "out"))
-                   (bash (assoc-ref %build-inputs "bash")))
-               (setenv "CONFIG_SHELL" (string-append bash "/bin/sh"))
-               (setenv "CC" "tcc")
-               (setenv "LD" "tcc")
-               (invoke "./configure" (string-append "--prefix=" out)))))
          (add-before 'configure 'remove-diff3-sdiff
            (lambda* (#:key outputs #:allow-other-keys)
              (substitute* "Makefile.in"
-               (("PROGRAMS = .*" all) "PROGRAMS = cmp diff"))
-             #t)))))))
+               (("PROGRAMS = .*" all) "PROGRAMS = cmp diff"))))
+         (replace 'configure           ; needs classic invocation of configure
+           (lambda* (#:key configure-flags #:allow-other-keys)
+             (let* ((out (assoc-ref %outputs "out"))
+                    (bash (assoc-ref %build-inputs "bash"))
+                    (shell (string-append bash "/bin/bash")))
+               (setenv "CONFIG_SHELL" shell)
+               (setenv "CC" "tcc")
+               (setenv "LD" "tcc")
+               (format (current-error-port)
+                       "running ./configure ~a\n" (string-join configure-flags))
+               (apply invoke (cons "./configure" configure-flags)))))
+         (replace 'install
+           (lambda _
+             (let* ((out (assoc-ref %outputs "out"))
+                    (bin (string-append out "/bin")))
+               (mkdir-p bin)
+               (install-file "cmp" bin)
+               (install-file "diff" bin)
+               #t))))))))
+
+(define patch-mesboot
+  ;; The initial patch.
+  (package
+    (inherit patch)
+    (name "patch-mesboot")
+    (version "2.5.9")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "mirror://gnu/patch/patch-"
+                                  version ".tar.gz"))
+              (sha256
+               (base32
+                "12nv7jx3gxfp50y11nxzlnmqqrpicjggw6pcsq0wyavkkm3cddgc"))))
+    (supported-systems '("i686-linux" "x86_64-linux"))
+    (inputs '())
+    (propagated-inputs '())
+    (native-inputs (%boot-tcc0-inputs))
+    (arguments
+     `(#:implicit-inputs? #f
+       #:guile ,%bootstrap-guile
+       #:parallel-build? #f
+       #:tests? #f            ; check is naive, also checks non-built PROGRAMS
+       #:strip-binaries? #f   ; no strip yet
+       #:configure-flags '("AR=tcc -ar" "CC=tcc" "LD-tcc")
+       #:phases
+       (modify-phases %standard-phases
+         (add-after 'unpack 'scripted-patch
+           (lambda _
+             ;; avoid another segfault
+             (substitute* "pch.c"
+               (("while [(]p_end >= 0[)]" all)
+                "p_end = -1;\nwhile (0)"))
+             #t))
+         ;; FIXME: no compressing gzip yet
+         (delete 'compress-documentation))))))
+
+(define sed-mesboot0
+  ;; The initial sed.
+  (package
+    (inherit sed)
+    (name "sed-mesboot0")
+    (version "1.18")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "mirror://gnu/sed/sed-"
+                                  version ".tar.gz"))
+              (sha256
+               (base32
+                "1hyv7i82jd0q18xcql51ylc8jwadp3gb3irgcqlis3v61p35jsv2"))))
+    (supported-systems '("i686-linux" "x86_64-linux"))
+    (inputs '())
+    (propagated-inputs '())
+    (native-inputs (%boot-tcc0-inputs))
+    (arguments
+     `(#:implicit-inputs? #f
+       #:guile ,%bootstrap-guile
+       #:parallel-build? #f
+       #:configure-flags '("CC=tcc")
+       #:make-flags '("CC=tcc" "extra_objs=" "DEFS=-D HAVE_BCOPY")
+       #:strip-binaries? #f             ; no strip yet
+       #:phases
+       (modify-phases %standard-phases
+         (add-after 'unpack 'scripted-patch
+           (lambda _
+             (let* ((out (assoc-ref %outputs "out"))
+                    (bash (assoc-ref %build-inputs "bash"))
+                    (shell (string-append bash "/bin/bash")))
+               (substitute* "configure"
+                 (("/bin/sh") shell))
+               #t)))
+         (replace 'check
+           (lambda _
+             (invoke "./sed" "--version")))
+         (replace 'install
+           (lambda _
+             (let* ((out (assoc-ref %outputs "out"))
+                    (bin (string-append out "/bin")))
+               (install-file "sed" bin)
+               #t))))))))
+
+(define (%boot-tcc-inputs)
+  `(("bash" ,bash-mesboot0)
+    ("bzip2" ,bzip2-mesboot)
+    ("diffutils" ,diffutils-mesboot)
+    ("gzip" ,gzip-mesboot)
+    ("patch" ,patch-mesboot)
+    ("sed" ,sed-mesboot0)
+    ("tcc" ,tcc-boot)
+    ,@(alist-delete "tcc" (%boot-tcc0-inputs))))
 
 (define binutils-mesboot0
+  ;; The initial Binutils
   (package
     (inherit binutils)
     (name "binutils-mesboot0")
-    (version "2.20.1a")
-    (source (bootstrap-origin
-             (origin
-               (method url-fetch)
-               (uri (string-append "mirror://gnu/binutils/binutils-"
-                                   version ".tar.bz2"))
-               (patches (search-patches "binutils-boot-2.20.1a.patch"))
-               (sha256
-                (base32
-                 "0r7dr0brfpchh5ic0z9r4yxqn4ybzmlh25sbp30cacqk8nb7rlvi")))))
+    (version "2.14")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "mirror://gnu/binutils/binutils-"
+                                  version ".tar.gz"))
+              (sha256
+               (base32
+                "1w8xp7k44bkijr974x9918i4p1sw4g2fcd5mxvspkjpg38m214ds"))))
     (inputs '())
     (propagated-inputs '())
-    (native-inputs `(("tcc" ,tcc-boot)
-
-                     ("bash" ,%bootstrap-coreutils&co)
-                     ("coreutils" ,%bootstrap-coreutils&co)
-                     ("diffutils" ,diffutils-mesboot)
-                     ("make" ,make-mesboot0)))
+    (native-inputs (%boot-tcc-inputs))
     (supported-systems '("i686-linux" "x86_64-linux"))
     (arguments
      `(#:implicit-inputs? #f
        #:guile ,%bootstrap-guile
-       #:tests? #f                                ; runtest: command not found
+       #:tests? #f                      ; runtest: command not found
        #:parallel-build? #f
-       #:strip-binaries? #f                       ; no strip yet
+       #:strip-binaries? #f             ; no strip yet
        #:configure-flags
-       (let ((cppflags (string-append " -D __GLIBC_MINOR__=6"
-                                      " -D MES_BOOTSTRAP=1"))
-             (bash (assoc-ref %build-inputs "bash")))
-         `(,(string-append "CONFIG_SHELL=" bash "/bin/sh")
-           ,(string-append "CPPFLAGS=" cppflags)
-           "AR=tcc -ar"
-           "CXX=false"
-           "RANLIB=true"
-           ,(string-append "CC=tcc" cppflags)
-           "--disable-nls"
+       (let ((out (assoc-ref %outputs "out")))
+         `("--disable-nls"
            "--disable-shared"
            "--disable-werror"
-           "--build=i686-unknown-linux-gnu"
-           "--host=i686-unknown-linux-gnu"
-           "--with-sysroot=/"))))))
+           "--build=i386-unknown-linux"
+           "--host=i386-unknown-linux"
+           "--target=i386-unknown-linux"
+           "--with-sysroot=/"
+           ,(string-append "--prefix=" out)))
+       #:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'setenv
+           (lambda _
+             (let* ((out (assoc-ref %outputs "out"))
+                    (bash (assoc-ref %build-inputs "bash"))
+                    (shell (string-append bash "/bin/bash")))
+               (setenv "CONFIG_SHELL" shell)
+               (setenv "SHELL" shell)
+               (setenv "AR" "tcc -ar")
+               (setenv "RANLIB" "true")
+               (setenv "CC" "tcc -D __GLIBC_MINOR__=6")
+               #t)))
+         (add-after 'unpack 'scripted-patch
+           (lambda* (#:key inputs #:allow-other-keys)
+             (substitute* "bfd/configure"
+               (("^sed -e '/SRC-POTFILES.*" all)
+                "echo -e 'all:\\n\\ttrue\\n\\ninstall:\\n\\ttrue\\n' > po/Makefile\n"))
+             #t))
+         (replace 'configure           ; needs classic invocation of configure
+           (lambda* (#:key configure-flags #:allow-other-keys)
+             (format (current-error-port)
+                     "running ./configure ~a\n" (string-join configure-flags))
+             (apply system* "./configure" configure-flags)
+             (substitute* "config.status"
+               (("[.]//dev/null") "/dev/null"))
+             (invoke "sh" "./config.status"))))))))
 
-(define gcc-core-mesboot
+(define gcc-core-mesboot0
   ;; Gcc-2.95.3 is the most recent GCC that is supported by what the Mes C
   ;; Library v0.16 offers.  Gcc-3.x (and 4.x) place higher demands on a C
   ;; library, such as dir.h/struct DIR/readdir, locales, signals...  Also,
-  ;; with gcc-2.95.3, binutils-boot-2.20.1a and glibc-2.2.5 we found a GNU
-  ;; toolchain triplet "that works".
+  ;; with gcc-2.95.3, binutils (2.14.0, 2.20.1a) and glibc-2.2.5 we found a
+  ;; GNU toolchain triplet "that works".
   (package
     (inherit gcc)
-    (name "gcc-core-mesboot")
+    (name "gcc-core-mesboot0")
     (version "2.95.3")
-    (source (bootstrap-origin
-             (origin
-               (method url-fetch)
-               (uri (string-append "mirror://gnu/gcc/gcc-2.95.3/gcc-core-"
-                                   version
-                                   ".tar.gz"))
-               (patches (search-patches "gcc-boot-2.95.3.patch"))
-               (sha256
-                (base32
-                 "1xvfy4pqhrd5v2cv8lzf63iqg92k09g6z9n2ah6ndd4h17k1x0an")))))
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "mirror://gnu/gcc/gcc-2.95.3/gcc-core-"
+                                  version
+                                  ".tar.gz"))
+              ;; `patches' needs XZ
+              ;; (patches (search-patches "gcc-boot-2.95.3.patch"))
+              (sha256
+               (base32
+                "1xvfy4pqhrd5v2cv8lzf63iqg92k09g6z9n2ah6ndd4h17k1x0an"))))
     (supported-systems '("i686-linux" "x86_64-linux"))
     (inputs '())
     (propagated-inputs '())
-    (native-inputs `(("binutils" ,binutils-mesboot0)
-                     ("tcc" ,tcc-boot)
-
-                     ("bash" ,%bootstrap-coreutils&co)
-                     ("coreutils" ,%bootstrap-coreutils&co)
-                     ("diffutils" ,diffutils-mesboot)
-                     ("make" ,make-mesboot0)))
+    (native-inputs `(("boot-patch" ,(search-patch "gcc-boot-2.95.3.patch"))
+                     ("binutils" ,binutils-mesboot0)
+                     ,@(%boot-tcc-inputs)))
     (outputs '("out"))
     (arguments
      `(#:implicit-inputs? #f
@@ -557,32 +1154,37 @@
            "--build=i686-unknown-linux-gnu"
            "--host=i686-unknown-linux-gnu"
            ,(string-append "--prefix=" out)))
-       #:make-flags (list
-                     "CC=tcc -static -D __GLIBC_MINOR__=6"
-                     "OLDCC=tcc -static -D __GLIBC_MINOR__=6"
-                     "CC_FOR_BUILD=tcc -static -D __GLIBC_MINOR__=6"
-                     "AR=ar"
-                     "RANLIB=ranlib"
-                     (string-append "LIBGCC2_INCLUDES=-I "
-                                    (assoc-ref %build-inputs "tcc")
-                                    "/include")
-                     "LANGUAGES=c"
-                     (string-append "BOOT_LDFLAGS="
-                                    " -B" (assoc-ref %build-inputs "tcc")
-                                    "/lib/"))
+       #:make-flags
+       `("CC=tcc -static -D __GLIBC_MINOR__=6"
+         "OLDCC=tcc -static -D __GLIBC_MINOR__=6"
+         "CC_FOR_BUILD=tcc -static -D __GLIBC_MINOR__=6"
+         "AR=ar"
+         "RANLIB=ranlib"
+         ,(string-append "LIBGCC2_INCLUDES=-I "
+                         (assoc-ref %build-inputs "tcc")
+                         "/include")
+         "LANGUAGES=c"
+         ,(string-append "BOOT_LDFLAGS="
+                         " -B" (assoc-ref %build-inputs "tcc")
+                         "/lib/"))
        #:modules ((guix build gnu-build-system)
                   (guix build utils)
                   (srfi srfi-1))
        #:phases
        (modify-phases %standard-phases
-         ;; gcc-2.95.3 needs more traditional configure
+         (add-after 'unpack 'apply-boot-patch
+           (lambda* (#:key inputs #:allow-other-keys)
+             (let ((patch-file (assoc-ref inputs "boot-patch")))
+               (system* "patch" "--force" "-p1" "-i" patch-file)
+               #t)))
          (add-before 'configure 'setenv
            (lambda* (#:key outputs #:allow-other-keys)
-             (let ((out (assoc-ref outputs "out"))
-                   (bash (assoc-ref %build-inputs "bash"))
-                   (tcc (assoc-ref %build-inputs "tcc"))
-                   (cppflags " -D __GLIBC_MINOR__=6"))
-               (setenv "CONFIG_SHELL" (string-append bash "/bin/sh"))
+             (let* ((out (assoc-ref outputs "out"))
+                    (bash (assoc-ref %build-inputs "bash"))
+                    (shell (string-append bash "/bin/bash"))
+                    (tcc (assoc-ref %build-inputs "tcc"))
+                    (cppflags " -D __GLIBC_MINOR__=6"))
+               (setenv "CONFIG_SHELL" shell)
                (setenv "CPPFLAGS" cppflags)
                (setenv "CC" (string-append "tcc" cppflags))
                (setenv "CC_FOR_BUILD" (string-append "tcc" cppflags))
@@ -591,9 +1193,9 @@
                  (lambda _
                    (display "
 ac_cv_c_float_format='IEEE (little-endian)'
-")))
-               #t)))
-         (replace 'configure
+"))))))
+         ;; gcc-2.95.3
+         (replace 'configure           ; needs classic invocation of configure
            (lambda* (#:key configure-flags  #:allow-other-keys)
              (format (current-error-port)
                      "running ./configure ~a\n" (string-join configure-flags))
@@ -611,34 +1213,36 @@ ac_cv_c_float_format='IEEE (little-endian)'
                     (gcc-dir (string-append
                               out "/lib/gcc-lib/i686-unknown-linux-gnu/2.95.3")))
                (mkdir-p "tmp")
-               (zero? (system (string-append "set -x; cd tmp && ar x ../gcc/libgcc2.a")))
-               (zero? (system (string-append "set -x; cd tmp && ar r " gcc-dir "/libgcc.a *.o")))
+               (with-directory-excursion "tmp"
+                 (invoke "ar" "x" (string-append "../gcc/libgcc2.a"))
+                 (invoke "ar" "x" (string-append tcc "/lib/libtcc1.a"))
+                 (apply invoke "ar" "r" (string-append gcc-dir "/libgcc.a")
+                        (find-files "." "\\.o")))
                (copy-file "gcc/libgcc2.a" (string-append out "/lib/libgcc2.a"))
                (copy-file (string-append tcc "/lib/libtcc1.a")
                           (string-append out "/lib/libtcc1.a"))
+               (invoke "ar" "x" (string-append tcc "/lib/libtcc1.a"))
+               (invoke "ar" "x" (string-append tcc "/lib/libc.a"))
                (invoke "ar" "r" (string-append gcc-dir "/libc.a")
-                       (string-append tcc-lib "/libc+gnu.o")
-                       (string-append tcc-lib "/libtcc1.o"))
-               (invoke "ar" "r" (string-append out "/lib/libc.a")
-                       (string-append tcc-lib "/libc+gnu.o")
-                       (string-append tcc-lib "/libtcc1.o"))
-               (invoke "ls" "-ltrF" gcc-dir)
-               (copy-recursively (string-append tcc "/include")
-                                 (string-append out "/include"))
+                       "libc.o" "libtcc1.o")
                #t))))))
     (native-search-paths
-     ;; Use the language-specific variables rather than 'CPATH' because they
-     ;; are equivalent to '-isystem' whereas 'CPATH' is equivalent to '-I'.
-     ;; The intent is to allow headers that are in the search path to be
-     ;; treated as "system headers" (headers exempt from warnings) just like
-     ;; the typical /usr/include headers on an FHS system.
      (list (search-path-specification
             (variable "C_INCLUDE_PATH")
-            (files '("include" "/lib/gcc-lib/i686-unknown-linux-gnu/2.95.3/include")))
+            (files '("include"
+
+                     ;; Needed to get things like GCC's <stddef.h>.
+                     "lib/gcc-lib/i686-unknown-linux-gnu/2.95.3/include")))
            (search-path-specification
             (variable "LIBRARY_PATH")
             (files '("lib")))))))
 
+(define (%boot-mesboot-core-inputs)
+  `(("binutils" ,binutils-mesboot0)
+    ("gawk" ,gawk-mesboot0)
+    ("gcc" ,gcc-core-mesboot0)
+    ,@(alist-delete "tcc" (%boot-tcc-inputs))))
+
 (define mesboot-headers
   (package
     (inherit mes-boot)
@@ -646,8 +1250,8 @@ ac_cv_c_float_format='IEEE (little-endian)'
     (supported-systems '("i686-linux" "x86_64-linux"))
     (inputs '())
     (propagated-inputs '())
-    (native-inputs `(("coreutils" ,%bootstrap-coreutils&co)
-                     ("headers" ,%bootstrap-linux-libre-headers)))
+    (native-inputs `(("kernel-headers" ,%bootstrap-linux-libre-headers)
+                     ,@(%boot-tcc-inputs)))
     (arguments
      `(#:implicit-inputs? #f
        #:guile ,%bootstrap-guile
@@ -661,20 +1265,79 @@ ac_cv_c_float_format='IEEE (little-endian)'
            (lambda* (#:key outputs #:allow-other-keys)
              (let* ((out (assoc-ref outputs "out"))
                     (include (string-append out "/include"))
-                    (headers (assoc-ref %build-inputs "headers" )))
+                    (headers (assoc-ref %build-inputs "kernel-headers")))
                (mkdir-p include)
                (copy-recursively "include" out)
                (copy-recursively headers out)
-               #t))))))
-    (native-search-paths
-     ;; Use the language-specific variables rather than 'CPATH' because they
-     ;; are equivalent to '-isystem' whereas 'CPATH' is equivalent to '-I'.
-     ;; The intent is to allow headers that are in the search path to be
-     ;; treated as "system headers" (headers exempt from warnings) just like
-     ;; the typical /usr/include headers on an FHS system.
-     (list (search-path-specification
-            (variable "C_INCLUDE_PATH")
-            (files '("include")))))))
+               #t))))))))
+
+(define gawk-mesboot0
+  ;; The initial Gawk.
+  (package
+    (inherit gawk)
+    (name "gawk-mesboot0")
+    (version "3.0.0")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "mirror://gnu/gawk/gawk-"
+                                  version ".tar.gz"))
+              (sha256
+               (base32
+                "087s7vpc8zawn3l7bwv9f44bf59rc398hvaiid63klw6fkbvabr3"))))
+    (supported-systems '("i686-linux" "x86_64-linux"))
+    (inputs '())
+    (propagated-inputs '())
+    (native-inputs (%boot-tcc-inputs))
+    (arguments
+     `(#:implicit-inputs? #f
+       #:guile ,%bootstrap-guile
+       #:configure-flags '("--build=i686-unknown-linux-gnu"
+                           "--host=i686-unknown-linux-gnu"
+                           "--disable-nls")
+       #:make-flags '("gawk")
+       #:parallel-build? #f
+       #:parallel-tests? #f
+       #:strip-binaries? #f             ; no strip yet
+       #:phases
+       (modify-phases %standard-phases
+         (add-after 'unpack 'scripted-patch
+           (lambda _
+             (substitute* "Makefile.in"
+               (("date ") "echo today ")
+               ((" autoheader") "true")
+               ((" -lm ") " "))
+             (substitute* "test/Makefile.in"
+               (("^bigtest:.*") "bigtest: basic\n")
+               (("( |\t)(childin|convfmt|fflush|longwrds|math|negexp)" all sep) sep))))
+         (add-before 'configure 'setenv
+           (lambda _
+             (let* ((out (assoc-ref %outputs "out"))
+                    (bash (assoc-ref %build-inputs "bash"))
+                    (shell (string-append bash "/bin/bash")))
+               (setenv "CONFIG_SHELL" shell)
+               (setenv "SHELL" shell)
+               (setenv "CC" "tcc")
+               (setenv "CPP" "tcc -E")
+               (setenv "LD" "tcc")
+               (setenv "ac_cv_func_getpgrp_void" "yes")
+               (setenv "ac_cv_func_tzset" "yes"))
+             #t))
+         (replace 'configure           ; needs classic invocation of configure
+           (lambda* (#:key configure-flags #:allow-other-keys)
+             (let* ((out (assoc-ref %outputs "out"))
+                    (configure-flags
+                     `(,@configure-flags
+                       ,(string-append "--prefix=" out))))
+               (format (current-error-port) "running ./configure ~a\n" (string-join configure-flags))
+               (system* "touch" "configure") ; aclocal.m4 is newer than configure
+               (apply invoke (cons "./configure" configure-flags)))))
+         (replace 'install
+           (lambda* (#:key outputs #:allow-other-keys)
+             (let* ((out (assoc-ref outputs "out"))
+                    (bin (string-append out "/bin")))
+               (install-file "gawk" bin)
+               (symlink "gawk" (string-append bin "/awk"))
+               #t))))))))
 
 (define glibc-mesboot0
   ;; GNU C Library 2.2.5 is the most recent glibc that we managed to build
@@ -684,33 +1347,30 @@ ac_cv_c_float_format='IEEE (little-endian)'
     (inherit glibc)
     (name "glibc-mesboot0")
     (version "2.2.5")
-    (source (bootstrap-origin
-             (origin
-               (method url-fetch)
-               (uri (string-append "mirror://gnu/glibc/glibc-"
-                                   version
-                                   ".tar.gz"))
-               (patches (search-patches "glibc-boot-2.2.5.patch"))
-               (sha256
-                (base32
-                 "1vl48i16gx6h68whjyhgnn1s57vqq32f9ygfa2fls7pdkbsqvp2q")))))
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "mirror://gnu/glibc/glibc-"
+                                  version
+                                  ".tar.gz"))
+              ;; Patch needs XZ
+              ;; (patches (search-patches "glibc-boot-2.2.5.patch"))
+              (sha256
+               (base32
+                "1vl48i16gx6h68whjyhgnn1s57vqq32f9ygfa2fls7pdkbsqvp2q"))))
     (supported-systems '("i686-linux" "x86_64-linux"))
     (inputs '())
     (propagated-inputs '())
-    (native-inputs `(("binutils" ,binutils-mesboot0)
-                     ("gcc" ,gcc-core-mesboot)
-
-                     ("bash" ,%bootstrap-coreutils&co)
-                     ("coreutils" ,%bootstrap-coreutils&co)
-                     ("diffutils" ,diffutils-mesboot)
+    (native-inputs `(("boot-patch" ,(search-patch "glibc-boot-2.2.5.patch"))
+                     ("system-patch" ,(search-patch "glibc-bootstrap-system-2.2.5.patch"))
                      ("headers" ,mesboot-headers)
-                     ("make" ,make-mesboot0)))
+                     ,@(%boot-mesboot-core-inputs)))
     (outputs '("out"))
     (arguments
      `(#:implicit-inputs? #f
        #:guile ,%bootstrap-guile
        #:tests? #f
        #:strip-binaries? #f
+       #:validate-runpath? #f   ; no dynamic executables
        #:parallel-build? #f     ; gcc-2.95.3 ICEs on massively parallel builds
        #:make-flags (list (string-append
                            "SHELL="
@@ -719,25 +1379,31 @@ ac_cv_c_float_format='IEEE (little-endian)'
        #:configure-flags
        (let ((out (assoc-ref %outputs "out"))
              (headers (assoc-ref %build-inputs "headers")))
-         (list
-          "--disable-shared"
-          "--enable-static"
-          "--disable-sanity-checks"
-          "--build=i686-unknown-linux-gnu"
-          "--host=i686-unknown-linux-gnu"
-          (string-append "--with-headers=" headers "/include")
-          "--enable-static-nss"
-          "--without-__thread"
-          "--without-cvs"
-          "--without-gd"
-          "--without-tls"
-          (string-append "--prefix=" out)))
+         `("--disable-shared"
+           "--enable-static"
+           "--disable-sanity-checks"
+           "--build=i686-unknown-linux-gnu"
+           "--host=i686-unknown-linux-gnu"
+           ,(string-append "--with-headers=" headers "/include")
+           "--enable-static-nss"
+           "--without-__thread"
+           "--without-cvs"
+           "--without-gd"
+           "--without-tls"
+           ,(string-append "--prefix=" out)))
        #:phases
        (modify-phases %standard-phases
+         (add-after 'unpack 'apply-boot-patch
+           (lambda* (#:key inputs #:allow-other-keys)
+             (and (let ((patch (assoc-ref inputs "boot-patch")))
+                    (invoke "patch" "--force" "-p1" "-i" patch))
+                  (let ((patch (assoc-ref inputs "system-patch")))
+                    (invoke "patch" "--force" "-p1" "-i" patch)))))
          (add-before 'configure 'setenv
            (lambda* (#:key outputs #:allow-other-keys)
              (let* ((out (assoc-ref outputs "out"))
                     (bash (assoc-ref %build-inputs "bash"))
+                    (shell (string-append bash "/bin/bash"))
                     (gcc (assoc-ref %build-inputs "gcc"))
                     (headers (assoc-ref %build-inputs "headers"))
                     (cppflags (string-append
@@ -745,88 +1411,63 @@ ac_cv_c_float_format='IEEE (little-endian)'
                                " -D MES_BOOTSTRAP=1"
                                " -D BOOTSTRAP_GLIBC=1"))
                     (cflags (string-append " -L " (getcwd))))
-               (setenv "CONFIG_SHELL" (string-append bash "/bin/sh"))
-               (setenv "SHELL" (getenv "CONFIG_SHELL"))
+               (setenv "CONFIG_SHELL" shell)
+               (setenv "SHELL" shell)
                (setenv "CPP" (string-append gcc "/bin/gcc -E " cppflags))
                (setenv "CC" (string-append gcc "/bin/gcc " cppflags cflags))
                #t)))
-         ;; glibc-2.2.5 needs a more classic invocation of configure
-         ;; configure: warning: CONFIG_SHELL=/gnu/store/…-bash-minimal-4.4.12/bin/bash: invalid host type
-         (replace 'configure
+         (replace 'configure           ; needs classic invocation of configure
            (lambda* (#:key configure-flags #:allow-other-keys)
              (format (current-error-port)
                      "running ./configure ~a\n" (string-join configure-flags))
-             (apply invoke "./configure" configure-flags))))))
-    (native-search-paths
-     ;; Use the language-specific variables rather than 'CPATH' because they
-     ;; are equivalent to '-isystem' whereas 'CPATH' is equivalent to '-I'.
-     ;; The intent is to allow headers that are in the search path to be
-     ;; treated as "system headers" (headers exempt from warnings) just like
-     ;; the typical /usr/include headers on an FHS system.
-     (list (search-path-specification
-            (variable "C_INCLUDE_PATH")
-            (files '("include")))
-           (search-path-specification
-            (variable "CPLUS_INCLUDE_PATH")
-            (files '("include")))
-           (search-path-specification
-            (variable "LIBRARY_PATH")
-            (files '("lib")))))))
+             (apply invoke "./configure" configure-flags)))
+                  (add-after 'configure 'fixup-configure
+                    (lambda _
+                      (let* ((out (assoc-ref %outputs "out"))
+                             (bash (assoc-ref %build-inputs "bash"))
+                             (shell (string-append bash "/bin/bash")))
+                        (substitute* "config.make"
+                          (("INSTALL = scripts/") "INSTALL = $(..)./scripts/"))
+                        (substitute* "config.make"
+                          (("INSTALL = scripts/") "INSTALL = $(..)./scripts/")
+                          (("BASH = ") (string-append
+                                        "SHELL = " shell "
+         BASH = ")))
+                        #t))))))))
 
 (define gcc-mesboot0
   (package
-    (inherit gcc-core-mesboot)
+    (inherit gcc-core-mesboot0)
     (name "gcc-mesboot0")
-    (native-inputs `(("binutils" ,binutils-mesboot0)
-                     ("gcc" ,gcc-core-mesboot)
+    (native-inputs `(("boot-patch" ,(search-patch "gcc-boot-2.95.3.patch"))
+                     ;; Packages are given in an order that's relevant for
+                     ;; #include_next purposes.
                      ("libc" ,glibc-mesboot0)
-
-                     ("bash" ,%bootstrap-coreutils&co)
-                     ("coreutils" ,%bootstrap-coreutils&co)
-                     ("diffutils" ,diffutils-mesboot)
                      ("kernel-headers" ,%bootstrap-linux-libre-headers)
-                     ("make" ,make-mesboot0)))
+                     ,@(%boot-mesboot-core-inputs)))
     (arguments
-     (substitute-keyword-arguments (package-arguments gcc-core-mesboot)
+     (substitute-keyword-arguments (package-arguments gcc-core-mesboot0)
        ((#:phases phases)
         `(modify-phases ,phases
            (replace 'setenv
-             (lambda* (#:key outputs #:allow-other-keys)
-               (let ((out (assoc-ref outputs "out"))
-                     (bash (assoc-ref %build-inputs "bash"))
-                     (gcc (assoc-ref %build-inputs "gcc"))
-                     (glibc (assoc-ref %build-inputs "libc"))
-                     (kernel-headers (assoc-ref %build-inputs "kernel-headers")))
-                 (setenv "CONFIG_SHELL" (string-append bash "/bin/sh"))
-                 (format (current-error-port) "C_INCLUDE_PATH=~a\n" (getenv "C_INCLUDE_PATH"))
-                 (setenv "C_INCLUDE_PATH" (string-append
-                                           gcc "/lib/gcc-lib/i686-unknown-linux-gnu/2.95.3/include"
-                                           ":" kernel-headers "/include"
-                                           ":" glibc "/include"))
-                 (format (current-error-port) "C_INCLUDE_PATH=~a\n" (getenv "C_INCLUDE_PATH"))
-                 (format (current-error-port) "LIBRARY_PATH=~a\n" (getenv "LIBRARY_PATH"))
-                 ;; FIXME: add glibc dirs to paths manually
-                 (setenv "LIBRARY_PATH" (string-join
-                                         (list (string-append glibc "/lib")
-                                               (getenv "LIBRARY_PATH"))
-                                         ":"))
-                 (format (current-error-port) "LIBRARY_PATH=~a\n" (getenv "LIBRARY_PATH"))
-                 (with-output-to-file "config.cache"
-                   (lambda _
-                     (display "
+             (lambda _
+               (setenv "CONFIG_SHELL" (which "sh"))
+               (with-output-to-file "config.cache"
+                 (lambda _
+                   (display "
 ac_cv_c_float_format='IEEE (little-endian)'
 ")))
-                 #t)))
+               #t))
            (replace 'install2
              (lambda* (#:key outputs #:allow-other-keys)
                (let* ((out (assoc-ref outputs "out"))
                       (gcc-dir (string-append
                                 out "/lib/gcc-lib/i686-unknown-linux-gnu/2.95.3")))
-                 (mkdir-p "tmp")
-                 (zero? (system (string-append "set -x; cd tmp && ar x ../gcc/libgcc2.a")))
-                 (zero? (system (string-append "set -x; cd tmp && ar r " gcc-dir "/libgcc.a *.o")))
-                 (copy-file "gcc/libgcc2.a" (string-append out "/lib/libgcc2.a"))
-                 #t)))))
+                 (and
+                  (mkdir-p "tmp")
+                  (zero? (system (string-append "set -x; cd tmp && ar x ../gcc/libgcc2.a")))
+                  (zero? (system (string-append "set -x; cd tmp && ar r " gcc-dir "/libgcc.a *.o")))
+                  (copy-file "gcc/libgcc2.a" (string-append out "/lib/libgcc2.a"))))))))
        ((#:configure-flags configure-flags)
         `(let ((out (assoc-ref %outputs "out")))
            `("--disable-shared"
@@ -840,32 +1481,166 @@ ac_cv_c_float_format='IEEE (little-endian)'
              ,(string-append "LIBGCC2_INCLUDES=-I " gcc "/include")
              "LANGUAGES=c")))))))
 
-(define binutils-mesboot
+(define (%boot-mesboot0-inputs)
+  `(("gcc" ,gcc-mesboot0)
+    ("kernel-headers" ,%bootstrap-linux-libre-headers)
+    ("libc" ,glibc-mesboot0)
+    ,@(alist-delete "gcc" (%boot-mesboot-core-inputs))))
+
+(define tar-mesboot
+  ;; Initial tar with support for xz compression.
   (package
-    (inherit binutils-mesboot0)
-    (name "binutils-mesboot")
-    (native-inputs `(("binutils" ,binutils-mesboot0)
-                     ("libc" ,glibc-mesboot0)
-                     ("gcc" ,gcc-mesboot0)
+    (inherit tar)
+    (name "tar-mesboot")
+    (version  "1.22")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "mirror://gnu/tar/tar-"
+                                  version ".tar.gz"))
+              (sha256
+               (base32
+                "19nvix64y95n5v6rr5g9g3fn08zz85cb5anzd7csfv4a4sz9lw4y"))))
+    (supported-systems '("i686-linux" "x86_64-linux"))
+    (inputs '())
+    (propagated-inputs '())
+    (native-inputs (%boot-mesboot0-inputs))
+    (arguments
+     `(#:implicit-inputs? #f
+       #:guile ,%bootstrap-guile
+       #:parallel-build? #f
+       #:tests? #f            ; check is naive, also checks non-built PROGRAMS
+       #:strip-binaries? #f   ; no strip yet
+       #:configure-flags '("--build=i686-unknown-linux-gnu"
+                           "--host=i686-unknown-linux-gnu"
+                           "--disable-nls")
+       #:phases
+       (modify-phases %standard-phases
+         (replace 'configure
+           (lambda* (#:key configure-flags #:allow-other-keys)
+             (let* ((out (assoc-ref %outputs "out"))
+                    (bash (assoc-ref %build-inputs "bash"))
+                    (shell (string-append bash "/bin/bash")))
+               (setenv "CONFIG_SHELL" shell)
+               (setenv "SHELL" shell)
+               (setenv "LIBS" "-lc -lnss_files -lnss_dns -lresolv")
+               (setenv "gl_cv_func_rename_dest_works" "yes")
+               (format (current-error-port)
+                       "running ./configure ~a\n" (string-join configure-flags))
+               (apply invoke (cons "./configure" configure-flags)))))
+         (add-after 'unpack 'scripted-patch
+           (lambda _
+             (let* ((bash (assoc-ref %build-inputs "bash"))
+                    (shell (string-append bash "/bin/bash")))
+               (substitute* "configure"
+                 ((" /bin/sh") shell)))
+             (substitute* "Makefile.in"
+               (("^SUBDIRS = doc") "SUBDIRS ="))
+             #t))
+         (replace 'install
+           (lambda _
+             (let* ((out (assoc-ref %outputs "out"))
+                    (bin (string-append out "/bin")))
+               (install-file "src/tar" bin)
+               #t))))))))
 
-                     ("bash" ,%bootstrap-coreutils&co)
-                     ("coreutils" ,%bootstrap-coreutils&co)
-                     ("diffutils" ,diffutils-mesboot)
-                     ("kernel-headers" ,%bootstrap-linux-libre-headers)
-                     ("make" ,make-mesboot0)))
+(define grep-mesboot
+  ;; The initial grep.
+  (package
+    (inherit grep)
+    (name "grep-mesboot")
+    (version "2.0")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "mirror://gnu/grep/grep-"
+                                  version ".tar.gz"))
+              (sha256
+               (base32
+                "1w862l80lgc5mxvpiy4cfwk761d6xxavn0m3xd2l7xs2kmzvp6lq"))))
+    (supported-systems '("i686-linux" "x86_64-linux"))
+    (inputs '())
+    (propagated-inputs '())
+    (native-inputs (%boot-mesboot0-inputs))
+    (arguments
+     `(#:implicit-inputs? #f
+       #:guile ,%bootstrap-guile
+       #:parallel-build? #f
+       #:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'patch-configure
+           (lambda _
+             (let* ((bash (assoc-ref %build-inputs "bash"))
+                    (shell (string-append bash "/bin/bash")))
+               (substitute* "configure"
+                 ((" [|][|] ./config.status") " || sh ./config.status")))))
+         (replace 'install
+           (lambda _
+             (let* ((out (assoc-ref %outputs "out"))
+                    (bin (string-append out "/bin")))
+               (install-file "grep" bin)
+               (symlink "grep" (string-append bin "/egrep"))
+               (symlink "grep" (string-append bin "/fgrep"))
+               #t))))))))
+
+(define binutils-mesboot1
+  (package
+    (inherit binutils-mesboot0)
+    (name "binutils-mesboot1")
+    (native-inputs (%boot-mesboot0-inputs))
     (arguments
      (substitute-keyword-arguments (package-arguments binutils-mesboot0)
        ((#:configure-flags configure-flags)
-        '(list "--disable-nls"
-               "--disable-shared"
-               "--disable-werror"
-               "--build=i686-unknown-linux-gnu"
-               "--host=i686-unknown-linux-gnu"
-               "--with-sysroot=/"))))))
+        '(let ((out (assoc-ref %outputs "out")))
+           `("--disable-nls"
+             "--disable-shared"
+             "--disable-werror"
+             "--build=i686-unknown-linux-gnu"
+             "--host=i686-unknown-linux-gnu"
+             "--with-sysroot=/"
+             ,(string-append "--prefix=" out))))
+       ((#:phases phases)
+        `(modify-phases ,phases
+           (replace 'setenv
+             (lambda _
+               (let* ((out (assoc-ref %outputs "out"))
+                      (bash (assoc-ref %build-inputs "bash"))
+                      (shell (string-append bash "/bin/bash")))
+                 (setenv "CONFIG_SHELL" shell)
+                 #t)))))))))
+
+(define coreutils-mesboot0
+  (package
+    (inherit coreutils)
+    (name "coreutils-mesboot0")
+    ;; The latest .gz release of Coreutils is 8.13; which does not build with gcc-2.95.3:
+    ;; randperm.c: In function `sparse_swap':
+    ;; randperm.c:117: invalid lvalue in unary `&'
+    (version "5.0")                     ; 2003-04
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "mirror://gnu/coreutils/coreutils-"
+                                  version ".tar.gz"))
+              (sha256
+               (base32
+                "10wq6k66i8adr4k08p0xmg87ff4ypiazvwzlmi7myib27xgffz62"))))
+    (native-inputs (%boot-mesboot0-inputs))
+    (supported-systems '("i686-linux" "x86_64-linux"))
+    (inputs '())
+    (propagated-inputs '())
+    (arguments
+     `(#:implicit-inputs? #f
+       #:tests? #f                      ; WARNING: `perl' is needed, ...
+       #:parallel-build? #f
+       #:strip-binaries? #f   ; strip: unrecognized option `--only-keep-debug'
+       #:guile ,%bootstrap-guile
+       #:configure-flags
+       '("--disable-doc"
+         "LIBS=-lc -lnss_files -lnss_dns -lresolv"
+         "ac_cv_func_gethostbyname=no"
+         "gl_cv_func_rename_dest_works=yes")))))
 
-(define make-mesboot
+(define gnu-make-mesboot
   (package
-    (inherit make-mesboot0)
+    (inherit gnu-make)
     (name "make-mesboot")
     (version "3.82")
     (source (origin
@@ -875,27 +1650,178 @@ ac_cv_c_float_format='IEEE (little-endian)'
               (sha256
                (base32
                 "1rs2f9hmvy3q6zkl15jnlmnpgffm0bhw5ax0h5c7q604wqrip69x"))))
-    (native-inputs `(("binutils" ,binutils-mesboot0)
-                     ("libc" ,glibc-mesboot0)
-                     ("gcc" ,gcc-mesboot0)
-                     ("make" ,make-mesboot0)
+    (native-inputs (%boot-mesboot0-inputs))
+    (supported-systems '("i686-linux" "x86_64-linux"))
+    (inputs '())
+    (propagated-inputs '())
+    (arguments
+     `(#:implicit-inputs? #f
+       #:parallel-build? #f
+       #:guile ,%bootstrap-guile
+       #:configure-flags '("LIBS=-lc -lnss_files -lnss_dns -lresolv")
+       #:phases
+       (modify-phases %standard-phases
+         (replace 'check
+           (lambda _
+             (invoke "./make" "--version")))
+         (replace 'install
+           (lambda* (#:key outputs #:allow-other-keys)
+             (let* ((out (assoc-ref outputs "out"))
+                    (bin (string-append out "/bin")))
+               (install-file "make" bin)
+               #t))))))))
 
-                     ("bash" ,%bootstrap-coreutils&co)
-                     ("coreutils" ,%bootstrap-coreutils&co)
-                     ("kernel-headers" ,%bootstrap-linux-libre-headers)))
+(define gawk-mesboot
+  (package
+    (inherit gawk)
+    (name "gawk-mesboot")
+    (version "3.1.8")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "mirror://gnu/gawk/gawk-"
+                                  version ".tar.gz"))
+              (sha256
+               (base32
+                "03d5y7jabq7p2s7ys9alay9446mm7i5g2wvy8nlicardgb6b6ii1"))))
+    (native-inputs `(,@(%boot-mesboot0-inputs)
+                     ("mesboot-headers" ,mesboot-headers)))
+    (supported-systems '("i686-linux" "x86_64-linux"))
+    (inputs '())
+    (propagated-inputs '())
     (arguments
-     (substitute-keyword-arguments (package-arguments make-mesboot0)
-       ((#:configure-flags configure-flags)
-        `(let ((out (assoc-ref %outputs "out")))
-           `(,(string-append "--prefix=" out))))
-       ((#:phases phases)
-        `(modify-phases ,phases
-           (delete 'configure-fixup)
-           (add-before 'configure 'setenv
-             (lambda _
-               (setenv "LIBS" "-lc -lnss_files -lnss_dns -lresolv")
+     `(#:implicit-inputs? #f
+       #:parallel-build? #f
+       #:guile ,%bootstrap-guile
+       #:configure-flags '("ac_cv_func_connect=no")
+       #:make-flags '("gawk")
+       #:phases
+       (modify-phases %standard-phases
+         (replace 'check
+           (lambda _
+             (invoke "./gawk" "--version")))
+         (replace 'install
+           (lambda* (#:key outputs #:allow-other-keys)
+             (let* ((out (assoc-ref outputs "out"))
+                    (bin (string-append out "/bin")))
+               (install-file "gawk" bin)
+               (symlink "gawk" (string-append bin "/awk"))
                #t))))))))
 
+(define sed-mesboot
+  (package
+    (inherit sed)
+    (name "sed-mesboot")
+    (version "4.0.6")                   ; 2003-04
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "mirror://gnu/sed/sed-"
+                                  version ".tar.gz"))
+              (sha256
+               (base32
+                "0861ij94cqc4vaaki6r2wlapwcmhpx4ggp4r70f46mb21a8fkvf1"))))
+    (native-inputs (%boot-mesboot0-inputs))
+    (supported-systems '("i686-linux" "x86_64-linux"))
+    (inputs '())
+    (propagated-inputs '())
+    (arguments
+     `(#:implicit-inputs? #f
+       #:parallel-build? #f
+       #:guile ,%bootstrap-guile
+       #:tests? #f                      ; 8to7 fails
+       #:phases
+       (modify-phases %standard-phases
+         (add-after 'unpack '/bin/sh
+           (lambda _
+             (let* ((bash (assoc-ref %build-inputs "bash"))
+                    (shell (string-append bash "/bin/bash")))
+               (substitute* "testsuite/Makefile.tests"
+                 (("^SHELL = /bin/sh")
+                  (string-append "SHELL = " shell)))
+               #t))))))))
+
+(define bash-mesboot
+  (package
+    (inherit bash-mesboot0)
+    (version "4.4")
+    (name "bash-mesboot")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "mirror://gnu/bash/bash-"
+                                  version ".tar.gz"))
+              (sha256
+               (base32
+                "1jyz6snd63xjn6skk7za6psgidsd53k05cr3lksqybi0q6936syq"))))
+    (inputs '())
+    (propagated-inputs '())
+    (native-inputs (%boot-mesboot0-inputs))
+    (outputs '("out"))
+    (arguments
+     `(#:implicit-inputs? #f
+       #:guile ,%bootstrap-guile
+       #:parallel-build? #f
+       #:configure-flags
+       '("--build=i686-unknown-linux-gnu"
+         "--host=i686-unknown-linux-gnu"
+
+         "--without-bash-malloc"
+         "--disable-readline"
+         "--disable-history"
+         "--disable-help-builtin"
+         "--disable-progcomp"
+         "--disable-net-redirections"
+         "--disable-nls"
+
+         ;; Pretend 'dlopen' is missing so we don't build loadable
+         ;; modules and related code.
+         "ac_cv_func_dlopen=no")
+       #:make-flags '("bash")
+       #:phases
+       (modify-phases %standard-phases
+         (add-after 'unpack 'scripted-patch
+           (lambda _
+             (substitute* "shell.c"
+               ((";;") ";"))
+             #t))
+         (add-before 'configure 'setenv
+           (lambda _
+             (setenv "AWK" "gawk")
+             (setenv "LIBS" "-lc -lnss_files -lnss_dns -lresolv")
+             (setenv "gl_cv_func_rename_dest_works" "yes")
+             #t))
+         (add-after 'configure 'configure-fixups
+           (lambda _
+             (let ((config.h (open-file "config.h" "a")))
+               (display (string-append "
+#define enable_hostname_completion(on_or_off) 0
+")
+                        config.h)
+               (close config.h))
+             #t))
+         (replace 'check
+           (lambda _
+             (invoke "./bash" "--version")))
+         (replace 'install
+           (lambda _
+             (let* ((out (assoc-ref %outputs "out"))
+                    (bin (string-append out "/bin")))
+               (mkdir-p bin)
+               (copy-file "bash" (string-append bin "/bash"))
+               (copy-file "bash" (string-append bin "/sh"))
+               #t))))))))
+
+(define (%boot-mesboot1-inputs)
+  `(("bash" ,bash-mesboot)
+    ("binutils" ,binutils-mesboot1)
+    ("coreutils" ,coreutils-mesboot0)
+    ("gawk" ,gawk-mesboot)
+    ("grep" ,grep-mesboot)
+    ("make" ,gnu-make-mesboot)
+    ("sed" ,sed-mesboot)
+    ("tar" ,tar-mesboot)
+    ,@(fold alist-delete (%boot-mesboot0-inputs)
+            '("bash" "binutils" "bootar" "coreutils" "gash"
+              "gawk" "grep" "guile" "make" "sed" "tar"))))
+
 (define gmp-boot
   (package
     (inherit gmp)
@@ -930,180 +1856,320 @@ ac_cv_c_float_format='IEEE (little-endian)'
                (base32
                 "1hzci2zrrd7v3g1jk35qindq05hbl0bhjcyyisq9z209xb3fqzb1"))))))
 
-(define gcc-mesboot1
+(define gcc-core-mesboot1
+  ;; GCC 4.6.4 is the latest modular distribution.  This package is not
+  ;; stricly needed, but very helpful for development because it builds
+  ;; relatively fast.  If this configures and builds then gcc-mesboot1 also
+  ;; builds.
   (package
     (inherit gcc-mesboot0)
-    (name "gcc-mesboot1")
-    (version "4.7.4")
-    (source (bootstrap-origin
-             (origin (inherit (package-source gcc-4.7))
-                     (patches (search-patches "gcc-boot-4.7.4.patch")))))
+    (name "gcc-core-mesboot1")
+    (version "4.6.4")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "mirror://gnu/gcc/gcc-"
+                                  version "/gcc-core-" version ".tar.gz"))
+              (sha256
+               (base32
+                "173kdb188qg79pcz073cj9967rs2vzanyjdjyxy9v0xb0p5sad75"))
+              ;; Patch needs XZ
+              ;; (patches (search-patches "gcc-boot-4.6.4.patch"))
+              ))
     (inputs `(("gmp-source" ,(package-source gmp-boot))
               ("mpfr-source" ,(package-source mpfr-boot))
               ("mpc-source" ,(package-source mpc-boot))))
-    (native-inputs `(("binutils" ,binutils-mesboot)
-                     ("gcc" ,gcc-mesboot0)
-                     ("libc" ,glibc-mesboot0)
+    (native-inputs `(("boot-patch" ,(search-patch "gcc-boot-4.6.4.patch"))
+                     ,@(%boot-mesboot1-inputs)))
+    (arguments
+     `(#:implicit-inputs? #f
+       #:guile ,%bootstrap-guile
+       #:tests? #f
+       #:modules ((guix build gnu-build-system)
+                  (guix build utils)
+                  (srfi srfi-1))
+       #:parallel-build? #f             ; for debugging
+       #:make-flags
+       (let* ((libc (assoc-ref %build-inputs "libc"))
+              (ldflags (string-append
+                        "-B" libc "/lib "
+                        "-Wl,-dynamic-linker "
+                        "-Wl," libc
+                        ,(glibc-dynamic-linker "i686-linux"))))
+         (list (string-append "LDFLAGS=" ldflags)
+               (string-append "LDFLAGS_FOR_TARGET=" ldflags)))
+       #:configure-flags
+       (let ((out (assoc-ref %outputs "out"))
+             (glibc (assoc-ref %build-inputs "libc")))
+         (list (string-append "--prefix=" out)
+               "--build=i686-unknown-linux-gnu"
+               "--host=i686-unknown-linux-gnu"
+               (string-append "--with-native-system-header-dir=" glibc "/include")
+               (string-append "--with-build-sysroot=" glibc "/include")
+               "--disable-bootstrap"
+               "--disable-decimal-float"
+               "--disable-libatomic"
+               "--disable-libcilkrts"
+               "--disable-libgomp"
+               "--disable-libitm"
+               "--disable-libmudflap"
+               "--disable-libquadmath"
+               "--disable-libsanitizer"
+               "--disable-libssp"
+               "--disable-libvtv"
+               "--disable-lto"
+               "--disable-lto-plugin"
+               "--disable-multilib"
+               "--disable-plugin"
+               "--disable-threads"
+               "--enable-languages=c"
+               "--enable-static"
+               "--disable-shared"
+               "--enable-threads=single"
+               "--disable-libstdcxx-pch"
+               "--disable-build-with-cxx"))
+       #:phases
+       (modify-phases %standard-phases
+         (add-after 'unpack 'apply-boot-patch
+           (lambda* (#:key inputs #:allow-other-keys)
+             (let ((patch-file (assoc-ref inputs "boot-patch")))
+               (format (current-error-port) "patch file=~s\n" patch-file)
+               (system* "patch" "--force" "-p1" "-i" patch-file))
+             #t))
+         ;; c&p from commencement.scm:gcc-boot0
+         (add-after 'unpack 'unpack-gmp&co
+           (lambda* (#:key inputs #:allow-other-keys)
+             (let ((gmp  (assoc-ref %build-inputs "gmp-source"))
+                   (mpfr (assoc-ref %build-inputs "mpfr-source"))
+                   (mpc  (assoc-ref %build-inputs "mpc-source")))
+
+               ;; To reduce the set of pre-built bootstrap inputs, build
+               ;; GMP & co. from GCC.
+               (for-each (lambda (source)
+                           (or (invoke "tar" "xvf" source)
+                               (error "failed to unpack tarball"
+                                      source)))
+                         (list gmp mpfr mpc))
+
+               ;; Create symlinks like `gmp' -> `gmp-x.y.z'.
+               ,@(map (lambda (lib)
+                        ;; Drop trailing letters, as gmp-6.0.0a unpacks
+                        ;; into gmp-6.0.0.
+                        `(symlink ,(string-trim-right
+                                    (package-full-name lib "-")
+                                    char-set:letter)
+                                  ,(package-name lib)))
+                      (list gmp-boot mpfr-boot mpc-boot))
+               #t)))
+         (add-before 'configure 'setenv
+           (lambda* (#:key outputs #:allow-other-keys)
+             (let* ((out (assoc-ref outputs "out"))
+                    (binutils (assoc-ref %build-inputs "binutils"))
+                    (bash (assoc-ref %build-inputs "bash"))
+                    (gcc (assoc-ref %build-inputs "gcc"))
+                    (glibc (assoc-ref %build-inputs "libc"))
+                    (kernel-headers (assoc-ref %build-inputs "kernel-headers")))
+               (setenv "CONFIG_SHELL" (string-append bash "/bin/sh"))
+               (setenv "C_INCLUDE_PATH" (string-append
+                                         gcc "/lib/gcc-lib/i686-unknown-linux-gnu/2.95.3/include"
+                                         ":" kernel-headers "/include"
+                                         ":" glibc "/include"
+                                         ":" (getcwd) "/mpfr/src"))
+               (setenv "LIBRARY_PATH" (string-append glibc "/lib"
+                                                     ":" gcc "/lib"))
+               (format (current-error-port) "C_INCLUDE_PATH=~a\n" (getenv "C_INCLUDE_PATH"))
+               (format (current-error-port) "LIBRARY_PATH=~a\n" (getenv "LIBRARY_PATH"))
+               #t))))))))
 
-                     ("bash" ,%bootstrap-coreutils&co)
-                     ("coreutils" ,%bootstrap-coreutils&co)
-                     ("diffutils" ,diffutils-mesboot)
-                     ("kernel-headers" ,%bootstrap-linux-libre-headers)
-                     ("make" ,make-mesboot)))
+(define gcc-mesboot1
+  (package
+    (inherit gcc-core-mesboot1)
+    (name "gcc-mesboot1")
+    (version "4.6.4")
+    (native-inputs
+     `(("gcc-g++"
+        ,(origin
+           (method url-fetch)
+           (uri (string-append "mirror://gnu/gcc/gcc-"
+                               version "/gcc-g++-" version ".tar.gz"))
+           (sha256
+            (base32
+             "1fqqk5zkmdg4vmqzdmip9i42q6b82i3f6yc0n86n9021cr7ms2k9"))))
+       ,@(package-native-inputs gcc-core-mesboot1)))
     (arguments
-     (substitute-keyword-arguments (package-arguments gcc-core-mesboot)
-       ((#:make-flags make-flags)
-        `(let* ((libc (assoc-ref %build-inputs "libc"))
-                (ldflags (string-append
-                          "-B" libc "/lib "
-                          "-Wl,-dynamic-linker "
-                          "-Wl," libc
-                          ,(glibc-dynamic-linker "i686-linux"))))
-           (list (string-append "LDFLAGS=" ldflags)
-                 (string-append "LDFLAGS_FOR_TARGET=" ldflags))))
+     (substitute-keyword-arguments (package-arguments gcc-core-mesboot1)
+       ((#:configure-flags configure-flags)
+        `(let ((out (assoc-ref %outputs "out")))
+           `("--enable-languages=c,c++"
+             ,@(filter
+                (negate (lambda (x) (string-prefix? "--enable-languages=" x)))
+                ,configure-flags))))
        ((#:phases phases)
         `(modify-phases ,phases
-           ;; c&p from commencement.scm:gcc-boot0
-           (add-after 'unpack 'unpack-gmp&co
-             (lambda* (#:key inputs #:allow-other-keys)
-               (let ((gmp  (assoc-ref %build-inputs "gmp-source"))
-                     (mpfr (assoc-ref %build-inputs "mpfr-source"))
-                     (mpc  (assoc-ref %build-inputs "mpc-source")))
-
-                 ;; To reduce the set of pre-built bootstrap inputs, build
-                 ;; GMP & co. from GCC.
-                 (for-each (lambda (source)
-                             (or (invoke "tar" "xvf" source)
-                                 (error "failed to unpack tarball"
-                                        source)))
-                           (list gmp mpfr mpc))
-
-                 ;; Create symlinks like `gmp' -> `gmp-x.y.z'.
-                 ,@(map (lambda (lib)
-                          ;; Drop trailing letters, as gmp-6.0.0a unpacks
-                          ;; into gmp-6.0.0.
-                          `(symlink ,(string-trim-right
-                                      (package-full-name lib "-")
-                                      char-set:letter)
-                                    ,(package-name lib)))
-                        (list gmp-boot mpfr-boot mpc-boot))
-                 #t)))
-           (delete 'remove-info)
+           (add-before 'unpack 'unpack-g++
+             (lambda _
+               (let ((source-g++ (assoc-ref %build-inputs "gcc-g++")))
+                 (invoke "tar" "xvf" source-g++))
+               #t))
            (replace 'setenv
-             (lambda* (#:key outputs #:allow-other-keys)
-               (let* ((out (assoc-ref outputs "out"))
-                      (binutils (assoc-ref %build-inputs "binutils"))
-                      (bash (assoc-ref %build-inputs "bash"))
-                      (gcc (assoc-ref %build-inputs "gcc"))
-                      (glibc (assoc-ref %build-inputs "libc"))
-                      (kernel-headers (assoc-ref %build-inputs "kernel-headers")))
-                 (setenv "CONFIG_SHELL" (string-append bash "/bin/sh"))
-                 (setenv "C_INCLUDE_PATH" (string-append
-                                           gcc "/lib/gcc-lib/i686-unknown-linux-gnu/2.95.3/include"
-                                           ":" kernel-headers "/include"
-                                           ":" glibc "/include"
-                                           ":" (getcwd) "/mpfr/src"))
-                 (setenv "LIBRARY_PATH" (string-append glibc "/lib"
-                                                       ":" gcc "/lib"))
-                 (format (current-error-port) "C_INCLUDE_PATH=~a\n" (getenv "C_INCLUDE_PATH"))
-                 (format (current-error-port) "LIBRARY_PATH=~a\n" (getenv "LIBRARY_PATH"))
-                 #t)))
-           (delete 'install2)))
-       ((#:configure-flags configure-flags)
-        `(let ((out (assoc-ref %outputs "out"))
-               (glibc (assoc-ref %build-inputs "libc")))
-           (list (string-append "--prefix=" out)
-                 "--build=i686-unknown-linux-gnu"
-                 "--host=i686-unknown-linux-gnu"
-
-                 (string-append "--with-native-system-header-dir=" glibc "/include")
-                 (string-append "--with-build-sysroot=" glibc "/include")
-
-                 "--disable-bootstrap"
-                 "--disable-decimal-float"
-                 "--disable-libatomic"
-                 "--disable-libcilkrts"
-                 "--disable-libgomp"
-                 "--disable-libitm"
-                 "--disable-libmudflap"
-                 "--disable-libquadmath"
-                 "--disable-libsanitizer"
-                 "--disable-libssp"
-                 "--disable-libvtv"
-                 "--disable-lto"
-                 "--disable-lto-plugin"
-                 "--disable-multilib"
-                 "--disable-plugin"
-                 "--disable-threads"
-                 "--enable-languages=c,c++"
-
-                 "--enable-static"
-                 ;; libstdc++.so: error: depends on 'libgcc_s.so.1', which cannot be found in RUNPATH ()
-                 "--disable-shared"
-                 "--enable-threads=single"
-
-                 ;; No pre-compiled libstdc++ headers, to save space.
-                 "--disable-libstdcxx-pch"
-
-                 ;; for libcpp ...
-                 "--disable-build-with-cxx")))))))
+             (lambda _
+               (setenv "CONFIG_SHELL" (which "sh"))
 
-(define gcc-mesboot1-wrapper
-  ;; We need this so gcc-mesboot1 can be used to create shared binaries that
-  ;; have the correct interpreter, otherwise configuring gcc-mesboot using
-  ;; --enable-shared will fail.
+               ;; Allow MPFR headers to be found.
+               (setenv "C_INCLUDE_PATH"
+                       (string-append (getcwd) "/mpfr/src:"
+                                      (getenv "C_INCLUDE_PATH")))
+
+               ;; Set the C++ search path so that C headers can be found as
+               ;; libstdc++ is being compiled.
+               (setenv "CPLUS_INCLUDE_PATH" (getenv "C_INCLUDE_PATH"))
+               #t))))))))
+
+(define (%boot-mesboot2-inputs)
+  `(("gcc" ,gcc-mesboot1)
+    ,@(alist-delete "gcc" (%boot-mesboot1-inputs))))
+
+(define xz-mesboot
+  ;; Finally, we can build xz.
   (package
-    (inherit gcc-mesboot1)
-    (name "gcc-mesboot1-wrapper")
-    (source #f)
+    (inherit xz)
+    (name "xz-mesboot")
+    (version "5.0.0")
+    (source (bootstrap-origin
+             (origin
+               (method url-fetch)
+               (uri (list (string-append "http://tukaani.org/xz/xz-" version
+                                         ".tar.gz")
+                          (string-append "http://multiprecision.org/guix/xz-"
+                                         version ".tar.gz")))
+               (sha256
+                (base32
+                 "0kf40ggbs1vaaj5s9k4csycahzqcf65n20pa6lngqhm6j0cj3agb")))))
+    (supported-systems '("i686-linux" "x86_64-linux"))
     (inputs '())
-    (native-inputs `(("bash" ,%bootstrap-coreutils&co)
-                     ("libc" ,glibc-mesboot)
-                     ("gcc" ,gcc-mesboot1)))
+    (outputs '("out"))
+    (propagated-inputs '())
+    (native-inputs (%boot-mesboot2-inputs))
     (arguments
      `(#:implicit-inputs? #f
        #:guile ,%bootstrap-guile
+       #:parallel-build? #f
+       #:configure-flags
+       `("--disable-assembler"
+         "--disable-shared"
+         "--enable-small"
+         "--disable-threads"
+         "--disable-xzdec"
+         "--disable-lzmadec"
+         "--disable-lzmainfo"
+         "--disable-lzma-links"
+         "--disable-scripts"
+         "--disable-doc"
+         "--disable-nls"
+         "--disable-symbol-versions"
+         ;; configure disqualifies BASH, CPP, GCC and GREP
+         ;; all of which seem fine for the build
+         "ac_cv_prog_cc_c99=-std=gnu9x"
+         "ac_cv_path_GREP=grep"
+         "gl_cv_posix_shell=bash"
+         "ac_cv_have_decl_optreset=no"
+         "CPPFLAGS=-D__GNUC__=1")))))
+
+(define hello-mesboot
+  ;; Check for Scheme-only bootstrap.
+  (package
+    (inherit hello)
+    (name "hello-mesboot")
+    (supported-systems '("i686-linux" "x86_64-linux"))
+    (inputs '())
+    (propagated-inputs '())
+    (native-inputs (%boot-mesboot2-inputs))
+    (arguments
+     `(#:implicit-inputs? #f
+       #:guile ,%bootstrap-guile
+       #:parallel-build? #f
+       ;; checking for grep that handles long lines and -e...
+       ;; configure: error: no acceptable grep could be found
+       #:configure-flags '("ac_cv_path_GREP=grep")
        #:phases
        (modify-phases %standard-phases
-         (delete 'unpack)
-         (delete 'configure)
-         (delete 'install)
-         (replace 'build
-           (lambda* (#:key outputs #:allow-other-keys)
-             (let* ((out (assoc-ref outputs "out"))
-                    (bash (assoc-ref %build-inputs "bash"))
-                    (libc (assoc-ref %build-inputs "libc"))
-                    (gcc (assoc-ref %build-inputs "gcc"))
-                    (bin (string-append out "/bin")))
-               (mkdir-p bin)
-               (for-each
-                (lambda (program)
-                  (let ((wrapper (string-append bin "/" program)))
-                    (with-output-to-file wrapper
-                      (lambda _
-                        (display (string-append "#! " bash "/bin/bash
-exec " gcc "/bin/" program
-" -Wl,--dynamic-linker"
-;; also for x86_64-linux, we are still on i686-linux
-" -Wl," libc ,(glibc-dynamic-linker "i686-linux")
-" -Wl,--rpath"
-" -Wl," libc "/lib"
-" \"$@\"
-"))
-                        (chmod wrapper #o555)))))
-                '(
-                  "gcc"
-                  "g++"
-                  "i686-unknown-linux-gnu-gcc"
-                  "i686-unknown-linux-gnu-g++"
-                  ))
-               #t)))
          (replace 'check
-           (lambda* (#:key outputs #:allow-other-keys)
-             (let* ((out (assoc-ref outputs "out"))
-                    (bin (string-append out "/bin"))
-                    (program (string-append bin "/gcc")))
-               (invoke program "--help")))))))))
+           (lambda _
+             (invoke "./hello"))))))))
+
+(define binutils-mesboot
+  (package
+    (inherit binutils)
+    (name "binutils-mesboot")
+    (version "2.20.1a")
+    (source (bootstrap-origin
+             (origin
+               (method url-fetch)
+               (uri (string-append "mirror://gnu/binutils/binutils-"
+                                   version ".tar.bz2"))
+               (patches (search-patches "binutils-boot-2.20.1a.patch"))
+               (sha256
+                (base32
+                 "0r7dr0brfpchh5ic0z9r4yxqn4ybzmlh25sbp30cacqk8nb7rlvi")))))
+    (inputs '())
+    (propagated-inputs '())
+    (native-inputs `(("xz" ,xz-mesboot)
+                     ,@(%boot-mesboot2-inputs)))
+    (supported-systems '("i686-linux" "x86_64-linux"))
+    (arguments
+     `(#:implicit-inputs? #f
+       #:guile ,%bootstrap-guile
+       #:tests? #f                     ; runtest: command not found
+       #:parallel-build? #f
+       #:strip-binaries? #f            ; no strip yet
+       #:configure-flags
+       `("CC=gcc"
+         "CXX=false"
+         "RANLIB=true"
+         "--disable-doc"
+         "--disable-nls"
+         "--disable-shared"
+         "--disable-werror"
+         "--build=i686-unknown-linux-gnu"
+         "--host=i686-unknown-linux-gnu"
+         "--with-sysroot=/"
+         ;; checking for grep that handles long lines and -e
+         "ac_cv_path_GREP=grep")
+       ;; FIXME: ac_cv_path_GREP=grep doesn't seem to be forwarded to
+       ;; cascading configure's?
+       #:make-flags '("ac_cv_path_GREP=grep")
+       #:phases
+       (modify-phases %standard-phases
+         (add-after 'unpack 'scripted-patch
+           (lambda _
+             ;; sed-mesboot0 cannot build these
+             (copy-file "binutils/Makefile.in" "binutils/Makefile.in.orig")
+             (substitute* "binutils/Makefile.in"
+               ;; binutils/binutils uses an amazingly complex install
+               ;; command, using FOR, SED, READ, IF, ECHO, SED, SED, AWK,
+               ;; READ, and then LIBTOOL (to do something like
+               ;; `mkdir $DESTDIR$bindir; cp readline $DESTDIR$bindir ...')
+
+               ;; Some tool [debugme!] cannot handle two escaped newlines
+               ;; (bash?), and the install stops after $(am__EXEEXT_11)
+               ;; ("objcopy"), so $(am__EXEEXT_13) ("readelf") and others do
+               ;; not get installed.  Remove the stray newline:
+               (("^\t@BUILD_NLMCONV@ @BUILD_SRCONV@ @BUILD_DLLTOOL@ @BUILD_WINDRES@ .*") ""))
+             (substitute* "opcodes/Makefile.in"
+               (("^SUBDIRS = [.] po") "SUBDIRS = ."))
+             (substitute* "binutils/Makefile.in"
+               (("^SUBDIRS = doc po") "SUBDIRS ="))
+             (substitute* "gas/Makefile.in"
+               (("^SUBDIRS = doc po") "SUBDIRS ="))
+             (substitute* "gprof/Makefile.in"
+               (("^SUBDIRS = po") "SUBDIRS ="))
+             (substitute* "ld/Makefile.in"
+               (("^SUBDIRS = po") "SUBDIRS ="))
+             #t)))))))
+
+(define (%boot-mesboot3-inputs)
+  `(("binutils" ,binutils-mesboot)
+    ("xz" ,xz-mesboot)
+    ,@(alist-delete "binutils" (%boot-mesboot2-inputs))))
 
 (define glibc-headers-mesboot
   (package
@@ -1121,17 +2187,8 @@ exec " gcc "/bin/" program
                (sha256
                 (base32
                  "0vlz4x6cgz7h54qq4528q526qlhnsjzbsvgc4iizn76cb0bfanx7")))))
-    (native-inputs `(("binutils" ,binutils-mesboot)
-                     ("libc" ,glibc-mesboot0)
-                     ("gcc" ,gcc-mesboot1)
-                     ("headers" ,mesboot-headers)
-
-                     ("bash" ,%bootstrap-coreutils&co)
-                     ("coreutils" ,%bootstrap-coreutils&co)
-                     ("diffutils" ,diffutils-mesboot)
-                     ("kernel-headers" ,%bootstrap-linux-libre-headers)
-                     ("make" ,make-mesboot)))
-
+    (native-inputs `(("headers" ,mesboot-headers)
+                     ,@(%boot-mesboot3-inputs)))
     (arguments
      (substitute-keyword-arguments (package-arguments glibc-mesboot0)
        ((#:configure-flags configure-flags)
@@ -1146,49 +2203,51 @@ exec " gcc "/bin/" program
             "--with-pthread"
             "--without-cvs"
             "--without-gd"
-            "--enable-add-ons=nptl")))
+            "--enable-add-ons=nptl"
+            ;; avoid: configure: error: confusing output from nm -u
+            "libc_cv_predef_stack_protector=no")))
        ((#:make-flags make-flags)
-        `(let ((bash (assoc-ref %build-inputs "bash")))
-           (list (string-append "SHELL=" bash "/bin/sh")
-                 "install-bootstrap-headers=yes" "install-headers")))
+        '(list "install-bootstrap-headers=yes" "install-headers"))
        ((#:phases phases)
         `(modify-phases ,phases
+           (delete 'apply-boot-patch)
+           (delete 'fixup-configure)
+           (delete 'set-path)
+           (replace 'unpack
+             (lambda* (#:key source #:allow-other-keys)
+               (invoke "tar" "xvf" source)
+               (chdir (string-append "glibc-" ,version))
+               #t))
            (replace 'setenv
-             (lambda* (#:key outputs #:allow-other-keys)
-               (let* ((out (assoc-ref outputs "out"))
-                      (headers (assoc-ref %build-inputs "headers"))
-                      (bash (assoc-ref %build-inputs "bash"))
-                      (coreutils (assoc-ref %build-inputs "coreutils"))
-                      (libc (assoc-ref %build-inputs "libc"))
-                      (gcc (assoc-ref %build-inputs "gcc"))
+             (lambda* (#:key inputs #:allow-other-keys)
+               (let* ((headers  (assoc-ref inputs "headers"))
+                      (libc     (assoc-ref inputs "libc"))
+                      (gcc      (assoc-ref inputs "gcc"))
                       (cppflags (string-append
                                  " -I " (getcwd) "/nptl/sysdeps/pthread/bits"
                                  " -D BOOTSTRAP_GLIBC=1"))
                       (cflags (string-append " -L " (getcwd)
                                              " -L " libc "/lib")))
                  (setenv "libc_cv_friendly_stddef" "yes")
-                 (setenv "CONFIG_SHELL" (string-append bash "/bin/sh"))
-                 (setenv "SHELL" (getenv "CONFIG_SHELL"))
-                 (format (current-error-port) "CONFIG_SHELL=~s\n" (getenv "CONFIG_SHELL"))
+                 (setenv "CONFIG_SHELL" (which "sh"))
+                 (setenv "SHELL" (which "sh"))
 
                  (setenv "CPP" (string-append gcc "/bin/gcc -E " cppflags))
                  (setenv "CC" (string-append gcc "/bin/gcc " cppflags cflags))
+                 (setenv "LD" "gcc")
 
                  ;; avoid -fstack-protector
                  (setenv "libc_cv_ssp" "false")
                  (substitute* "configure"
-                   (("/bin/pwd") (string-append coreutils "/bin/pwd")))
-                 (setenv "C_INCLUDE_PATH" (string-append libc "/include"
-                                                         headers "/include"))
-                 (setenv "LIBRARY_PATH" (string-append libc "/lib"))
+                   (("/bin/pwd") "pwd"))
                  #t)))
            (replace 'install
              (lambda* (#:key outputs make-flags #:allow-other-keys)
                (let ((kernel-headers (assoc-ref %build-inputs "kernel-headers"))
                      (out (assoc-ref outputs "out")))
-                 (apply invoke "make" make-flags)
-                 (copy-recursively kernel-headers out)
-                 #t)))
+                 (and (apply invoke "make" make-flags)
+                      (copy-recursively kernel-headers out)
+                      #t))))
            (replace 'configure
              (lambda* (#:key configure-flags #:allow-other-keys)
                (format (current-error-port) "running ../configure ~a\n" (string-join configure-flags))
@@ -1197,36 +2256,37 @@ exec " gcc "/bin/" program
                (apply invoke "../configure" configure-flags)))
            (add-after 'configure 'remove-sunrpc
              (lambda _
-               (invoke "make" (string-append (getcwd) "/sysd-sorted" )
-                       (string-append "SHELL=" (getenv "CONFIG_SHELL")))
-               (substitute* "sysd-sorted"
-                 ((" sunrpc") " ")
-                 ((" nis") " "))
-               ;; 'rpcgen' needs native libc headers to be built.
-               (substitute* "../Makefile"
-                 (("^SHELL := /bin/sh") (string-append "SHELL := " (getenv "CONFIG_SHELL"))))
-               (substitute* "../Makeconfig"
-                 (("^SHELL := /bin/sh") (string-append "SHELL := " (getenv "CONFIG_SHELL"))))
-               (substitute* "../elf/Makefile"
-                 (("^SHELL := /bin/sh") (string-append "SHELL := " (getenv "CONFIG_SHELL"))))))))))))
+               (let* ((out (assoc-ref %outputs "out"))
+                      (bash (assoc-ref %build-inputs "bash"))
+                      (shell (string-append bash "/bin/bash")))
+
+                 (let ((Makefile (open-file "Makefile" "a")))
+                   (display (string-append "
+
+SHELL := " shell "
+")
+                            Makefile)
+                   (close Makefile))
+                 (substitute* "../Makefile"
+                   (("^SHELL := /bin/sh") (string-append "SHELL := " shell)))
+                 (substitute* "../Makeconfig"
+                   (("^SHELL := /bin/sh") (string-append "SHELL := " shell)))
+                 (substitute* "../elf/Makefile"
+                   (("^SHELL := /bin/sh") (string-append "SHELL := " shell)))
+                 (invoke "make" (string-append (getcwd) "/sysd-sorted" ))
+                 (substitute* "sysd-sorted"
+                   ((" sunrpc") " ")
+                   ((" nis") " "))
+                 #t)))))))))
 
 (define glibc-mesboot
   (package
     (inherit glibc-headers-mesboot)
     (name "glibc-mesboot")
-    (native-inputs `(("binutils" ,binutils-mesboot)
-                     ("libc" ,glibc-mesboot0)
-                     ("headers" ,glibc-headers-mesboot)
-                     ("gcc" ,gcc-mesboot1)
-
-                     ("bash" ,%bootstrap-coreutils&co)
-                     ("coreutils" ,%bootstrap-coreutils&co)
-                     ("diffutils" ,diffutils-mesboot)
-                     ("kernel-headers" ,%bootstrap-linux-libre-headers)
-                     ("make" ,make-mesboot)))
-
+    (native-inputs `(("headers" ,glibc-headers-mesboot)
+                     ,@(%boot-mesboot3-inputs)))
     (arguments
-     `(#:validate-runpath? #f               ; fails when using --enable-shared
+     `(#:validate-runpath? #f ; fails when using --enable-shared
        ,@(substitute-keyword-arguments (package-arguments glibc-headers-mesboot)
            ((#:make-flags make-flags)
             `(let ((bash (assoc-ref %build-inputs "bash")))
@@ -1238,41 +2298,82 @@ exec " gcc "/bin/" program
                    (let* ((kernel-headers (assoc-ref %build-inputs "kernel-headers"))
                           (out (assoc-ref outputs "out"))
                           (install-flags (cons "install" make-flags)))
-                     (apply invoke "make" install-flags)
-                     (copy-recursively kernel-headers out)
-                     #t))))))))
-    (native-search-paths ;; FIXME: move to glibc-mesboot0
-     ;; Use the language-specific variables rather than 'CPATH' because they
-     ;; are equivalent to '-isystem' whereas 'CPATH' is equivalent to '-I'.
-     ;; The intent is to allow headers that are in the search path to be
-     ;; treated as "system headers" (headers exempt from warnings) just like
-     ;; the typical /usr/include headers on an FHS system.
-     (list (search-path-specification
-            (variable "C_INCLUDE_PATH")
-            (files '("include")))
-           (search-path-specification
-            (variable "CPLUS_INCLUDE_PATH")
-            (files '("include")))
-           (search-path-specification
-            (variable "LIBRARY_PATH")
-            (files '("lib")))))))
+                     (and (apply invoke "make" install-flags)
+                          (copy-recursively kernel-headers out)
+                          #t)))))))))))
+
+(define (%boot-mesboot4-inputs)
+  `(("libc" ,glibc-mesboot)
+    ,@(alist-delete "libc" (%boot-mesboot3-inputs))))
+
+(define gcc-mesboot1-wrapper
+  ;; We need this so gcc-mesboot1 can be used to create shared binaries that
+  ;; have the correct interpreter, otherwise configuring gcc-mesboot using
+  ;; --enable-shared will fail.
+  (package
+    (inherit gcc-mesboot1)
+    (name "gcc-mesboot1-wrapper")
+    (source #f)
+    (inputs '())
+    (native-inputs `(("bash" ,bash-mesboot)
+                     ("coreutils" ,coreutils-mesboot0)
+                     ("libc" ,glibc-mesboot)
+                     ("gcc" ,gcc-mesboot1)))
+    (arguments
+     `(#:implicit-inputs? #f
+       #:guile ,%bootstrap-guile
+       #:phases
+       (modify-phases %standard-phases
+         (delete 'unpack)
+         (delete 'configure)
+         (delete 'install)
+         (replace 'build
+           (lambda* (#:key outputs #:allow-other-keys)
+             (let* ((out (assoc-ref outputs "out"))
+                    (bash (assoc-ref %build-inputs "bash"))
+                    (libc (assoc-ref %build-inputs "libc"))
+                    (gcc (assoc-ref %build-inputs "gcc"))
+                    (bin (string-append out "/bin")))
+               (mkdir-p bin)
+               (for-each
+                (lambda (program)
+                  (let ((wrapper (string-append bin "/" program)))
+                    (with-output-to-file wrapper
+                      (lambda _
+                        (display (string-append "#! " bash "/bin/bash
+exec " gcc "/bin/" program
+" -Wl,--dynamic-linker"
+;; also for x86_64-linux, we are still on i686-linux
+" -Wl," libc ,(glibc-dynamic-linker "i686-linux")
+" -Wl,--rpath"
+" -Wl," libc "/lib"
+" \"$@\"
+"))
+                        (chmod wrapper #o555)))))
+                '("cpp"
+                  "gcc"
+                  "g++"
+                  "i686-unknown-linux-gnu-cpp"
+                  "i686-unknown-linux-gnu-gcc"
+                  "i686-unknown-linux-gnu-g++"))
+               #t)))
+         (replace 'check
+           (lambda* (#:key outputs #:allow-other-keys)
+             (let* ((out (assoc-ref outputs "out"))
+                    (bin (string-append out "/bin"))
+                    (program (string-append bin "/gcc")))
+               (invoke program "--help")))))))))
 
 (define gcc-mesboot
   (package
     (inherit gcc-mesboot1)
     (name "gcc-mesboot")
-    (version "4.9.4")
+    (version (package-version gcc-4.9))
     (source (bootstrap-origin (package-source gcc-4.9)))
-    (native-inputs `(("binutils" ,binutils-mesboot)
-                     ("gcc-wrapper" ,gcc-mesboot1-wrapper)
+    (native-inputs `(("gcc-wrapper" ,gcc-mesboot1-wrapper)
                      ("gcc" ,gcc-mesboot1)
-                     ("libc" ,glibc-mesboot)
-
-                     ("bash" ,%bootstrap-coreutils&co)
-                     ("coreutils" ,%bootstrap-coreutils&co)
-                     ("diffutils" ,diffutils-mesboot)
-                     ("kernel-headers" ,%bootstrap-linux-libre-headers)
-                     ("make" ,make-mesboot)))
+                     ("headers" ,glibc-headers-mesboot)
+                     ,@(%boot-mesboot4-inputs)))
     (arguments
      `(#:validate-runpath? #f
        ,@(substitute-keyword-arguments (package-arguments gcc-mesboot1)
@@ -1317,6 +2418,9 @@ exec " gcc "/bin/" program
                      "--disable-build-with-cxx")))
            ((#:phases phases)
             `(modify-phases ,phases
+               (delete 'apply-boot-patch)
+               (delete 'unpack-g++)     ; sadly, gcc-4.9.4 does not provide
+                                        ; modular core/language downloads
                (replace 'setenv
                  (lambda* (#:key outputs #:allow-other-keys)
                    (let* ((out (assoc-ref outputs "out"))
@@ -1327,12 +2431,12 @@ exec " gcc "/bin/" program
                           (kernel-headers (assoc-ref %build-inputs "kernel-headers")))
                      (setenv "CONFIG_SHELL" (string-append bash "/bin/sh"))
                      (setenv "C_INCLUDE_PATH" (string-append
-                                               gcc "/lib/gcc-lib/i686-unknown-linux-gnu/4.7.4/include"
+                                               gcc "/lib/gcc-lib/i686-unknown-linux-gnu/4.6.4/include"
                                                ":" kernel-headers "/include"
                                                ":" glibc "/include"
                                                ":" (getcwd) "/mpfr/src"))
                      (setenv "CPLUS_INCLUDE_PATH" (string-append
-                                                   gcc "/lib/gcc-lib/i686-unknown-linux-gnu/4.7.4/include"
+                                                   gcc "/lib/gcc-lib/i686-unknown-linux-gnu/4.6.4/include"
                                                    ":" kernel-headers "/include"
                                                    ":" glibc "/include"
                                                    ":" (getcwd) "/mpfr/src"))
@@ -1352,49 +2456,41 @@ exec " gcc "/bin/" program
     (version (package-version gcc-mesboot))
     (source #f)
     (inputs '())
-    (native-inputs `(("bash" ,%bootstrap-coreutils&co)
+    (native-inputs `(("bash" ,bash-mesboot)
+                     ("coreutils" ,coreutils-mesboot0)
                      ("libc" ,glibc-mesboot)
                      ("gcc" ,gcc-mesboot)))))
 
-(define m4-mesboot
+(define (%boot-mesboot5-inputs)
+  `(("gcc-wrapper" ,gcc-mesboot-wrapper)
+    ("gcc" ,gcc-mesboot)
+    ,@(fold alist-delete (%boot-mesboot4-inputs) '("gcc" "gcc-wrapper"))))
+
+(define coreutils-mesboot
   (package
-    (inherit m4)
-    (name "m4-mesboot")
-    (version "1.4")
-    (source (origin
-              (method url-fetch)
-              (uri (string-append "mirror://gnu/m4/m4-"
-                                  version ".tar.gz"))
-              (sha256
-               (base32
-                "1f9bxj176kf3pvs350w2dfs8jgwhminywri5pyn01b11yc4yhsjw"))))
+    (inherit coreutils)
+    (name "coreutils-mesboot")
+    (source (bootstrap-origin (package-source coreutils)))
+    (native-inputs (%boot-mesboot5-inputs))
     (supported-systems '("i686-linux" "x86_64-linux"))
-    (native-inputs `(("mes" ,mes-boot)
-                     ("tcc" ,tcc-boot)))
+    (inputs '())
+    (propagated-inputs '())
     (arguments
-     `(#:phases
-       (modify-phases %standard-phases
-         (replace 'configure
-           (lambda* (#:key outputs #:allow-other-keys)
-             (let ((out (assoc-ref outputs "out")))
-               (setenv "CONFIG_SHELL" (string-append
-                                       (assoc-ref %build-inputs "bash")
-                                       "/bin/sh"))
-               (setenv "CC" "tcc -static")
-               (setenv "CPP" "tcc -E")
-               (invoke "./configure" (string-append "--prefix=" out))))))))))
+     `(#:implicit-inputs? #f
+       #:guile ,%bootstrap-guile
+       #:tests? #f))))
+
+(define (%boot-mesboot6-inputs)
+  `(("coreutils" ,coreutils-mesboot)
+    ,@(fold alist-delete (%boot-mesboot5-inputs)
+            '("coreutils" "kernel-headers"))))
 
 (define (%bootstrap-inputs+toolchain)
-  ;; The traditional bootstrap-inputs.  For the i686-linux Reduced Binary Seed
-  ;; the actual reduced set with bootstrapped toolchain.
+  ;; The traditional bootstrap-inputs.  For the i686-linux, x86_64-linux
+  ;; Scheme-only bootstrap the actual reduced set with bootstrapped toolchain.
   (match (%current-system)
     ((or "i686-linux" "x86_64-linux")
-     `(("libc" ,glibc-mesboot)
-       ("binutils" ,binutils-mesboot)
-       ("gcc-wrapper" ,gcc-mesboot-wrapper)
-       ("gcc" ,gcc-mesboot)
-       ,@(fold alist-delete (%bootstrap-inputs)
-               '("bootstrap-mescc-tools" "mes"))))
+     (%boot-mesboot6-inputs))
     (_
      (%bootstrap-inputs))))
 
@@ -1408,6 +2504,11 @@ exec " gcc "/bin/" program
        #:implicit-inputs? #f
        #:tests? #f                                ; cannot run "make check"
        ,@(substitute-keyword-arguments (package-arguments gnu-make)
+           ((#:configure-flags flags ''())
+            ;; The generated config.status has some problems due to the
+            ;; bootstrap environment.  Disable dependency tracking to work
+            ;; around it.
+            `(cons "--disable-dependency-tracking" ,flags))
            ((#:phases phases)
             `(modify-phases ,phases
                (replace 'build
@@ -1422,6 +2523,35 @@ exec " gcc "/bin/" program
     (native-inputs '())                           ; no need for 'pkg-config'
     (inputs (%bootstrap-inputs+toolchain))))
 
+(define bzip2-boot0
+  (package
+    (inherit bzip2)
+    (name "bzip2-boot0")
+    (native-inputs `())
+    (inputs
+     `(("diffutils" ,diffutils-boot0)
+       ("make" ,gnu-make-boot0)
+       ,@(%bootstrap-inputs+toolchain)))
+    (arguments
+     `(#:guile ,%bootstrap-guile
+       #:implicit-inputs? #f
+       ,@(package-arguments bzip2)))))
+
+(define coreutils-boot0
+  (package
+    (inherit coreutils)
+    (source (bootstrap-origin (package-source coreutils)))
+    (name "coreutils-boot0")
+    (native-inputs `())
+    (inputs
+     `(("make" ,gnu-make-boot0)
+       ,@(%bootstrap-inputs+toolchain)))
+    (arguments
+     `(#:tests? #f
+       #:implicit-inputs? #f
+       #:guile ,%bootstrap-guile
+       ,@(package-arguments coreutils)))))
+
 (define diffutils-boot0
   (package
     (inherit diffutils)
@@ -1434,7 +2564,15 @@ exec " gcc "/bin/" program
      `(#:tests? #f                            ; the test suite needs diffutils
        #:guile ,%bootstrap-guile
        #:implicit-inputs? #f
-       ,@(package-arguments diffutils)))))
+       ,@(match (%current-system)
+           ((or "arm-linux" "aarch64-linux")
+            (substitute-keyword-arguments (package-arguments diffutils)
+              ((#:configure-flags flags ''())
+               ;; The generated config.status has some problems due to the
+               ;; bootstrap environment.  Disable dependency tracking to work
+               ;; around it.
+               `(cons "--disable-dependency-tracking" ,flags))))
+           (_ '()))))))
 
 (define findutils-boot0
   (package
@@ -1448,7 +2586,31 @@ exec " gcc "/bin/" program
     (arguments
      `(#:implicit-inputs? #f
        #:guile ,%bootstrap-guile
-       ,@(package-arguments findutils)))))
+
+       ;; The build system assumes we have done a mistake when time_t is 32-bit
+       ;; on a 64-bit system.  Ignore that for our bootstrap toolchain.
+       ,@(substitute-keyword-arguments (package-arguments findutils)
+           ((#:configure-flags flags ''())
+            `(append
+              ,(if (target-64bit?)
+                   ''("TIME_T_32_BIT_OK=yes")
+                   ''())
+              ,(match (%current-system)
+                 ((or "arm-linux" "aarch64-linux")
+                  ''("--disable-dependency-tracking"))
+                 (_ ''()))
+              ,flags)))))))
+
+(define file
+  (package
+    (inherit (@ (gnu packages file) file))
+    (arguments
+     `(#:configure-flags
+       `("--disable-bzlib"
+         ,,@(match (%current-system)
+              ((or "arm-linux" "aarch64-linux")
+               '("--disable-dependency-tracking"))
+              (_ '())))))))
 
 (define file-boot0
   (package
@@ -1459,13 +2621,87 @@ exec " gcc "/bin/" program
      `(("make" ,gnu-make-boot0)
        ,@(%bootstrap-inputs+toolchain)))
     (arguments
-     `(#:implicit-inputs? #f
+     `(#:tests? #f                      ; merge test fails
+       #:implicit-inputs? #f
+       #:guile ,%bootstrap-guile
+       #:configure-flags '("--disable-bzlib")
+       #:strip-binaries? #f
+       #:validate-runpath? #f
+       ,@(package-arguments file)))))
+
+(define gawk-boot0
+  (package
+    (inherit patch)
+    (source (bootstrap-origin (package-source gawk)))
+    (name "gawk-boot0")
+    (native-inputs '())
+    (inputs
+     `(("make" ,gnu-make-boot0)
+       ,@(%bootstrap-inputs+toolchain)))
+    (arguments
+     `(#:tests? #f
+       #:implicit-inputs? #f
+       #:guile ,%bootstrap-guile
+       #:strip-binaries? #f
+       #:validate-runpath? #f))))
+
+(define patch-boot0
+  (package
+    (inherit patch)
+    (source (bootstrap-origin (package-source patch)))
+    (name "patch-boot0")
+    (native-inputs '())
+    (inputs
+     `(("make" ,gnu-make-boot0)
+       ,@(%bootstrap-inputs+toolchain)))
+    (arguments
+     `(#:tests? #f                      ; merge test fails
+       #:implicit-inputs? #f
        #:guile ,%bootstrap-guile
        #:strip-binaries? #f
        #:validate-runpath? #f))))
 
+(define sed-boot0
+  (package
+    (inherit sed)
+    (name "sed-boot0")
+    (source (bootstrap-origin (package-source sed)))
+    (native-inputs '())
+    (inputs
+     `(("make" ,gnu-make-boot0)
+       ,@(%bootstrap-inputs+toolchain)))
+    (arguments
+     `(#:implicit-inputs? #f
+       #:tests? #f
+       #:guile ,%bootstrap-guile
+       ,@(package-arguments sed)))))
+
+(define tar-boot0
+  (package
+    (inherit tar)
+    (name "tar-boot0")
+    (source (bootstrap-origin (package-source tar)))
+    (native-inputs '())
+    (inputs
+     `(("make" ,gnu-make-boot0)
+       ,@(%bootstrap-inputs+toolchain)))
+    (arguments
+     `(#:implicit-inputs? #f
+       #:tests? #f
+       #:guile ,%bootstrap-guile
+       ,@(package-arguments tar)))))
+
 (define (%boot0-inputs)
-  `(("make" ,gnu-make-boot0)
+  `(,@(match (%current-system)
+        ((or "i686-linux" "x86_64-linux")
+         `(("bzip2" ,bzip2-boot0)
+           ("coreutils" ,coreutils-boot0)
+           ("gawk" ,gawk-boot0)
+           ("patch" ,patch-boot0)
+           ("sed" ,sed-boot0)
+           ("tar" ,tar-boot0)))
+        (_ '()))
+    ("make" ,gnu-make-boot0)
     ("diffutils" ,diffutils-boot0)
     ("findutils" ,findutils-boot0)
     ("file" ,file-boot0)
@@ -1714,20 +2950,13 @@ exec " gcc "/bin/" program
        #:implicit-inputs? #f
        ,@(package-arguments m4)))))
 
-(define m4-boot0*
-  (package
-    ;; TODO: On the next rebuild cycle, use M4-BOOT0 as is.
-    (inherit m4-boot0)
-    (name "m4")))
-
 (define bison-boot0
   ;; This Bison is needed to build MiG so we need it early in the process.
   ;; Recent versions of Linux-Libre headers also depend on this.
   (package
     (inherit bison)
-    ;; TODO: On the next build cycle, do:
-    ;;(name "bison-boot0")
-    (propagated-inputs `(("m4" ,m4-boot0*)))
+    (name "bison-boot0")
+    (propagated-inputs `(("m4" ,m4-boot0)))
     (native-inputs `(("perl" ,perl-boot0)))
     (inputs (%boot0-inputs))                      ;remove Flex...
     (arguments
@@ -1735,17 +2964,6 @@ exec " gcc "/bin/" program
        #:implicit-inputs? #f
        #:guile ,%bootstrap-guile
 
-       ;; XXX: These flags should be unconditional, but for now
-       ;; we just add them on x86 to avoid a full rebuild.
-       ;; TODO: On the next core-updates, use
-       ;; 'substitute-keyword-arguments' to inherit them from
-       ;; BISON.
-       ,@(if (member (%current-system)
-                     '("x86_64-linux" "i686-linux"))
-             '(#:parallel-build? #f
-               #:parallel-tests? #f)
-             '())
-
        ;; Zero timestamps in liby.a; this must be done
        ;; explicitly here because the bootstrap Binutils don't
        ;; do that (default is "cru".)
@@ -1756,53 +2974,90 @@ exec " gcc "/bin/" program
                            "RANLIB=ranlib")
                           (_
                            "RANLIB=ranlib -D"))
-                      "V=1")))))
+                      "V=1")
+
+       ,@(package-arguments bison)))))
 
 (define flex-boot0
   ;; This Flex is needed to build MiG as well as Linux-Libre headers.
-  (let ((m4-boot0* (package (inherit m4-boot0*))))
-    (package
-      (inherit flex)
-      (native-inputs `(("bison" ,bison-boot0)))
-      (propagated-inputs
-       ;; XXX: Here we use an 'm4-boot0' package that's not eq? so that it
-       ;; appears twice in '%build-inputs', like when we were using
-       ;; 'package-with-explicit-inputs'.
-       ;; TODO: Remove this hack on the next rebuild cycle.
-       `(("m4" ,m4-boot0*)))
-      (inputs (%boot0-inputs))
-      (arguments
-       `(#:implicit-inputs? #f
-         #:guile ,%bootstrap-guile
-         #:tests? #f)))))
-
-(define linux-libre-headers-boot0
-  (mlambda ()
-    "Return Linux-Libre header files for the bootstrap environment."
-    ;; Note: this is wrapped in a thunk to nicely handle circular dependencies
-    ;; between (gnu packages linux) and this module.  Additionally, memoize
-    ;; the result to play well with further memoization and code that relies
-    ;; on pointer identity; see <https://bugs.gnu.org/30155>.
-    (package
-      (inherit linux-libre-headers)
-      (arguments
-       `(#:guile ,%bootstrap-guile
-         #:implicit-inputs? #f
-         ,@(package-arguments linux-libre-headers)))
-      (native-inputs
-       `(("perl" ,perl-boot0)
+  (package
+    (inherit flex)
+    (native-inputs `(("bison" ,bison-boot0)))
+    (propagated-inputs `(("m4" ,m4-boot0)))
+    (inputs (%boot0-inputs))
+    (arguments
+     `(#:implicit-inputs? #f
+       #:guile ,%bootstrap-guile
+       #:tests? #f))))
 
-         ;; Flex and Bison are required since version 4.16.
-         ("flex" ,flex-boot0)
-         ("bison" ,bison-boot0)
-         ,@(%boot0-inputs))))))
+(define rsync-boot0
+  (package
+    (inherit rsync)
+    (native-inputs `(("perl" ,perl-boot0)))
+    (inputs (%boot0-inputs))
+    (arguments
+     `(#:implicit-inputs? #f
+       #:guile ,%bootstrap-guile))))
+
+(define-syntax define/system-dependent
+  (lambda (s)
+    "Bind IDENTIFIER to EXP, where the value of EXP is known to depend on
+'%current-system'.  The definition ensures that (1) EXP is \"thunked\" so that
+it sees the right value of '%current-system', and (2) that its result is
+memoized as a function of '%current-system'."
+    (syntax-case s ()
+      ((_ identifier exp)
+       (with-syntax ((memoized (datum->syntax #'identifier
+                                              (symbol-append
+                                               (syntax->datum #'identifier)
+                                               '/memoized))))
+         #'(begin
+             (define memoized
+               (mlambda (system) exp))
+             (define-syntax identifier
+               (identifier-syntax (memoized (%current-system))))))))))
+
+(define/system-dependent linux-libre-headers-boot0
+  ;; Note: this is wrapped in a thunk to nicely handle circular dependencies
+  ;; between (gnu packages linux) and this module.  Additionally, memoize
+  ;; the result to play well with further memoization and code that relies
+  ;; on pointer identity; see <https://bugs.gnu.org/30155>.
+  (package
+    (inherit linux-libre-headers)
+    (arguments
+     `(#:guile ,%bootstrap-guile
+       #:implicit-inputs? #f
+       ,@(package-arguments linux-libre-headers)))
+    (native-inputs
+     `(("perl" ,perl-boot0)
+
+       ;; Flex and Bison are required since version 4.16.
+       ("flex" ,flex-boot0)
+       ("bison" ,bison-boot0)
+
+       ;; Rsync is required since version 5.3.
+       ("rsync" ,rsync-boot0)
+       ,@(%boot0-inputs)))))
 
 (define with-boot0
   (package-with-explicit-inputs %boot0-inputs
                                 %bootstrap-guile))
 
 (define gnumach-headers-boot0
-  (with-boot0 (package-with-bootstrap-guile gnumach-headers)))
+  (with-boot0
+   (package-with-bootstrap-guile
+    (package
+      (inherit gnumach-headers)
+      (version "1.8-116-g28b53508")
+      (source (bootstrap-origin
+               (origin
+                 (method url-fetch)
+                 (uri (string-append "https://lilypond.org/janneke/hurd/"
+                                     "gnumach-" version ".tar.gz"))
+                 (sha256
+                  (base32
+                   "006i0zgwy81vxarpfm12vip4q6i5mgmi5mmy5ldvxp5hx9h3l0zg")))))
+      (native-inputs '())))))
 
 (define mig-boot0
   (let* ((mig (package
@@ -1816,35 +3071,50 @@ exec " gcc "/bin/" program
                                       (assoc-ref %build-inputs "flex") "/lib/")))))))
     (with-boot0 mig)))
 
+(define hurd-version-boot0 "0.9-229-ga1efcee8")
+(define hurd-source-boot0
+  (let ((version hurd-version-boot0))
+    (bootstrap-origin
+     (origin
+       (method url-fetch)
+       (uri (string-append "https://lilypond.org/janneke/hurd/"
+                           "hurd-v" version ".tar.gz"))
+       (sha256
+        (base32
+         "0bq2q2jisxcy0kgcm6rz0z2fddwxxm7azsama7li28a2m08kdpzy"))))))
+
 (define hurd-headers-boot0
   (let ((hurd-headers (package (inherit hurd-headers)
-                        (native-inputs `(("mig" ,mig-boot0)))
-                        (inputs '()))))
+                               (version hurd-version-boot0)
+                               (source hurd-source-boot0)
+                               (native-inputs `(("mig" ,mig-boot0)))
+                               (inputs '()))))
     (with-boot0 (package-with-bootstrap-guile hurd-headers))))
 
 (define hurd-minimal-boot0
   (let ((hurd-minimal (package (inherit hurd-minimal)
-                        (native-inputs `(("mig" ,mig-boot0)))
-                        (inputs '()))))
+                               (version hurd-version-boot0)
+                               (source hurd-source-boot0)
+                               (native-inputs `(("mig" ,mig-boot0)))
+                               (inputs '()))))
     (with-boot0 (package-with-bootstrap-guile hurd-minimal))))
 
-(define hurd-core-headers-boot0
-  (mlambda ()
-    "Return the Hurd and Mach headers as well as initial Hurd libraries for
-the bootstrap environment."
-    (package (inherit (package-with-bootstrap-guile hurd-core-headers))
-             (arguments `(#:guile ,%bootstrap-guile
-                          ,@(package-arguments hurd-core-headers)))
-             (inputs
-              `(("gnumach-headers" ,gnumach-headers-boot0)
-                ("hurd-headers" ,hurd-headers-boot0)
-                ("hurd-minimal" ,hurd-minimal-boot0)
-                ,@(%boot0-inputs))))))
+(define/system-dependent hurd-core-headers-boot0
+  ;; Return the Hurd and Mach headers as well as initial Hurd libraries for
+  ;; the bootstrap environment.
+  (package (inherit (package-with-bootstrap-guile hurd-core-headers))
+           (arguments `(#:guile ,%bootstrap-guile
+                        ,@(package-arguments hurd-core-headers)))
+           (inputs
+            `(("gnumach-headers" ,gnumach-headers-boot0)
+              ("hurd-headers" ,hurd-headers-boot0)
+              ("hurd-minimal" ,hurd-minimal-boot0)
+              ,@(%boot0-inputs)))))
 
 (define* (kernel-headers-boot0 #:optional (system (%current-system)))
   (match system
-    ("i586-gnu" (hurd-core-headers-boot0))
-    (_ (linux-libre-headers-boot0))))
+    ("i586-gnu" hurd-core-headers-boot0)
+    (_ linux-libre-headers-boot0)))
 
 (define texinfo-boot0
   ;; Texinfo used to build libc's manual.
@@ -1892,16 +3162,24 @@ the bootstrap environment."
     ;; pthreads, which is missing on non-x86 platforms at this stage.
     ;; Python 3.6 technically supports being built without threading
     ;; support, but requires additional patches.
-    (version "3.5.7")
+    (version "3.5.9")
     (source (bootstrap-origin
              (origin
-               (inherit (package-source python))
+               (method url-fetch)
                (uri (string-append "https://www.python.org/ftp/python/"
                                    version "/Python-" version ".tar.xz"))
-               (patches '())
                (sha256
                 (base32
-                 "1p67pnp2ca5przx2s45r8m55dcn6f5hsm0l4s1zp7mglkf4r4n18")))))
+                 "0jdh9pvx6m6lfz2liwvvhn7vks7qrysqgwn517fkpxb77b33fjn2"))
+               (modules '((guix build utils)))
+               (snippet
+                '(begin
+                   ;; Delete the bundled copy of libexpat.
+                   (delete-file-recursively "Modules/expat")
+                   (substitute* "Modules/Setup.dist"
+                     ;; Link Expat instead of embedding the bundled one.
+                     (("^#pyexpat.*") "pyexpat pyexpat.c -lexpat\n"))
+                   #t)))))
     (inputs
      `(,@(%boot0-inputs)
        ("expat" ,expat-sans-tests)))              ;remove OpenSSL, zlib, etc.
@@ -1919,7 +3197,17 @@ the bootstrap environment."
            ;; Python package won't interfere with this one.
            ((#:make-flags _ ''()) ''())
            ((#:phases phases)
-            `(modify-phases ,phases
+            ;; Remove the 'apply-alignment-patch' phase if present to avoid
+            ;; rebuilding this package.  TODO: for the next rebuild cycle,
+            ;; consider inlining all the arguments instead of inheriting to
+            ;; make it easier to patch Python without risking a full rebuild.
+            ;; Or better yet, change to 'python-on-guile'.
+            `(modify-phases ,@(list (match phases
+                                      (('modify-phases original-phases
+                                         changes ...
+                                         ('add-after unpack apply-alignment-patch _))
+                                       `(modify-phases ,original-phases ,@changes))
+                                      (_ phases)))
                (add-before 'configure 'disable-modules
                  (lambda _
                    (substitute* "setup.py"
@@ -1929,24 +3217,34 @@ the bootstrap environment."
                      ;; built, since it requires Linux headers.
                      (("'linux', ") ""))
                    #t))
-               (delete 'set-TZDIR)))
+               (delete 'set-TZDIR)
+               ,@(if (hurd-system?)
+                     `((add-before 'build 'fix-regen
+                         (lambda* (#:key inputs #:allow-other-keys)
+                           (let ((libc (assoc-ref inputs "libc")))
+                             (substitute* "Lib/plat-generic/regen"
+                               (("/usr/include/") (string-append libc "/include/")))
+                             #t))))
+                     '())))
            ((#:tests? _ #f) #f))))))
 
-(define ld-wrapper-boot0
-  (mlambda ()
-    ;; We need this so binaries on Hurd will have libmachuser and libhurduser
-    ;; in their RUNPATH, otherwise validate-runpath will fail.
-    (make-ld-wrapper "ld-wrapper-boot0"
-                     #:target boot-triplet
-                     #:binutils binutils-boot0
-                     #:guile %bootstrap-guile
-                     #:bash (car (assoc-ref (%boot0-inputs) "bash"))
-                     #:guile-for-build %bootstrap-guile)))
+(define/system-dependent ld-wrapper-boot0
+  ;; The first 'ld' wrapper, defined with 'define/system-dependent' because
+  ;; its calls '%boot0-inputs', whose result depends on (%current-system)
+  ;;
+  ;; We need this so binaries on Hurd will have libmachuser and libhurduser
+  ;; in their RUNPATH, otherwise validate-runpath will fail.
+  (make-ld-wrapper "ld-wrapper-boot0"
+                   #:target boot-triplet
+                   #:binutils binutils-boot0
+                   #:guile %bootstrap-guile
+                   #:bash (car (assoc-ref (%boot0-inputs) "bash"))
+                   #:guile-for-build %bootstrap-guile))
 
 (define (%boot1-inputs)
   ;; 2nd stage inputs.
   `(("gcc" ,gcc-boot0)
-    ("ld-wrapper-cross" ,(ld-wrapper-boot0))
+    ("ld-wrapper-cross" ,ld-wrapper-boot0)
     ("binutils-cross" ,binutils-boot0)
     ,@(alist-delete "binutils" (%boot0-inputs))))
 
@@ -1967,7 +3265,9 @@ the bootstrap environment."
            ((#:configure-flags flags)
             `(append (list ,(string-append "--host=" (boot-triplet))
                            ,(string-append "--build="
-                                           (nix-system->gnu-triplet)))
+                                           (nix-system->gnu-triplet))
+                           ,(if (hurd-system?) "--disable-werror"
+                                ""))
                      ,flags))
            ((#:phases phases)
             `(modify-phases ,phases
@@ -1978,13 +3278,14 @@ the bootstrap environment."
                    (unsetenv "CPATH")
 
                    ;; Tell 'libpthread' where to find 'libihash' on Hurd systems.
-                   ,@(if (hurd-triplet? (%current-system))
-                         `((substitute* "libpthread/Makefile"
-                             (("LDLIBS-pthread.so =.*")
-                              (string-append "LDLIBS-pthread.so = "
-                                             (assoc-ref %build-inputs "kernel-headers")
-                                             "/lib/libihash.a\n"))))
-                         '())
+                   ,@(if (hurd-system?)
+                       '((substitute* '("sysdeps/mach/Makefile"
+                                        "sysdeps/mach/hurd/Makefile")
+                           (("LDLIBS-pthread.so =.*")
+                            (string-append "LDLIBS-pthread.so = "
+                                           (assoc-ref %build-inputs "kernel-headers")
+                                           "/lib/libihash.a\n"))))
+                       '())
 
                    ;; 'rpcgen' needs native libc headers to be built.
                    (substitute* "sunrpc/Makefile"
@@ -2005,7 +3306,7 @@ the bootstrap environment."
        ,@(%boot1-inputs)
 
        ;; A native MiG is needed to build Glibc on Hurd.
-       ,@(if (hurd-triplet? (%current-system))
+       ,@(if (hurd-system?)
              `(("mig" ,mig-boot0))
              '())
 
@@ -2069,20 +3370,19 @@ exec ~a/bin/~a-~a -B~a/lib -Wl,-dynamic-linker -Wl,~a/~a \"$@\"~%"
        ("bash" ,bash)))
     (inputs '())))
 
-(define gcc-boot0-intermediate-wrapped
-  (mlambda ()
-    ;; Make the cross-tools GCC-BOOT0 and BINUTILS-BOOT0 available under the
-    ;; non-cross names.
-    (cross-gcc-wrapper gcc-boot0 binutils-boot0
-                       glibc-final-with-bootstrap-bash
-                       (car (assoc-ref (%boot1-inputs) "bash")))))
+(define/system-dependent gcc-boot0-intermediate-wrapped
+  ;; Make the cross-tools GCC-BOOT0 and BINUTILS-BOOT0 available under the
+  ;; non-cross names.
+  (cross-gcc-wrapper gcc-boot0 binutils-boot0
+                     glibc-final-with-bootstrap-bash
+                     (car (assoc-ref (%boot1-inputs) "bash"))))
 
 (define static-bash-for-glibc
   ;; A statically-linked Bash to be used by GLIBC-FINAL in system(3) & co.
   (package
     (inherit static-bash)
     (source (bootstrap-origin (package-source static-bash)))
-    (inputs `(("gcc" ,(gcc-boot0-intermediate-wrapped))
+    (inputs `(("gcc" ,gcc-boot0-intermediate-wrapped)
               ("libc" ,glibc-final-with-bootstrap-bash)
               ("libc:static" ,glibc-final-with-bootstrap-bash "static")
               ,@(fold alist-delete (%boot1-inputs)
@@ -2160,24 +3460,27 @@ exec ~a/bin/~a-~a -B~a/lib -Wl,-dynamic-linker -Wl,~a/~a \"$@\"~%"
    ;; if 'allowed-references' were per-output.
    (arguments
     `(#:allowed-references
-      ,(cons* `(,gcc-boot0 "lib") (kernel-headers-boot0)
-              static-bash-for-glibc
-              (package-outputs glibc-final-with-bootstrap-bash))
-
+      ((,gcc-boot0 "lib")
+       ,(kernel-headers-boot0)
+       ,static-bash-for-glibc
+       ,@(if (hurd-system?)
+             `(,gnumach-headers-boot0
+               ,hurd-headers-boot0)
+             '())
+       ,@(package-outputs glibc-final-with-bootstrap-bash))
       ,@(package-arguments glibc-final-with-bootstrap-bash)))))
 
-(define gcc-boot0-wrapped
-  (mlambda ()
-    ;; Make the cross-tools GCC-BOOT0 and BINUTILS-BOOT0 available under the
-    ;; non-cross names.
-    (cross-gcc-wrapper gcc-boot0 binutils-boot0 glibc-final
-                       (car (assoc-ref (%boot1-inputs) "bash")))))
+(define/system-dependent gcc-boot0-wrapped
+  ;; Make the cross-tools GCC-BOOT0 and BINUTILS-BOOT0 available under the
+  ;; non-cross names.
+  (cross-gcc-wrapper gcc-boot0 binutils-boot0 glibc-final
+                     (car (assoc-ref (%boot1-inputs) "bash"))))
 
 (define (%boot2-inputs)
   ;; 3rd stage inputs.
   `(("libc" ,glibc-final)
     ("libc:static" ,glibc-final "static")
-    ("gcc" ,(gcc-boot0-wrapped))
+    ("gcc" ,gcc-boot0-wrapped)
     ,@(fold alist-delete (%boot1-inputs) '("libc" "gcc" "linux-libre-headers"))))
 
 (define binutils-final
@@ -2231,14 +3534,13 @@ exec ~a/bin/~a-~a -B~a/lib -Wl,-dynamic-linker -Wl,~a/~a \"$@\"~%"
        ,@(package-arguments zlib)))
     (inputs (%boot2-inputs))))
 
-(define ld-wrapper-boot3
-  (mlambda ()
-    ;; A linker wrapper that uses the bootstrap Guile.
-    (make-ld-wrapper "ld-wrapper-boot3"
-                     #:binutils binutils-final
-                     #:guile %bootstrap-guile
-                     #:bash (car (assoc-ref (%boot2-inputs) "bash"))
-                     #:guile-for-build %bootstrap-guile)))
+(define/system-dependent ld-wrapper-boot3
+  ;; A linker wrapper that uses the bootstrap Guile.
+  (make-ld-wrapper "ld-wrapper-boot3"
+                   #:binutils binutils-final
+                   #:guile %bootstrap-guile
+                   #:bash (car (assoc-ref (%boot2-inputs) "bash"))
+                   #:guile-for-build %bootstrap-guile))
 
 (define gcc-final
   ;; The final GCC.
@@ -2300,15 +3602,6 @@ exec ~a/bin/~a-~a -B~a/lib -Wl,-dynamic-linker -Wl,~a/~a \"$@\"~%"
                                            char-set:letter)
                                          ,(package-name lib)))
                              (list gmp-6.0 mpfr mpc))
-                      #t)))
-                (add-before 'configure 'treat-glibc-as-system-header
-                  (lambda* (#:key inputs #:allow-other-keys)
-                    (let ((libc (assoc-ref inputs "libc")))
-                      ;; Make sure Glibc is treated as a "system header" so
-                      ;; #include_next does the right thing.
-                      (for-each (lambda (var)
-                                  (setenv var (string-append libc "/include")))
-                                '("C_INCLUDE_PATH" "CPLUS_INCLUDE_PATH"))
                       #t))))))))
 
     ;; This time we want Texinfo, so we get the manual.  Add
@@ -2323,7 +3616,7 @@ exec ~a/bin/~a-~a -B~a/lib -Wl,-dynamic-linker -Wl,~a/~a \"$@\"~%"
     (inputs `(("gmp-source" ,(bootstrap-origin (package-source gmp-6.0)))
               ("mpfr-source" ,(package-source mpfr))
               ("mpc-source" ,(package-source mpc))
-              ("ld-wrapper" ,(ld-wrapper-boot3))
+              ("ld-wrapper" ,ld-wrapper-boot3)
               ("binutils" ,binutils-final)
               ("libstdc++" ,libstdc++)
               ("zlib" ,zlib-final)
@@ -2332,7 +3625,7 @@ exec ~a/bin/~a-~a -B~a/lib -Wl,-dynamic-linker -Wl,~a/~a \"$@\"~%"
 (define (%boot3-inputs)
   ;; 4th stage inputs.
   `(("gcc" ,gcc-final)
-    ("ld-wrapper" ,(ld-wrapper-boot3))
+    ("ld-wrapper" ,ld-wrapper-boot3)
     ,@(alist-delete "gcc" (%boot2-inputs))))
 
 (define bash-final
@@ -2364,7 +3657,7 @@ exec ~a/bin/~a-~a -B~a/lib -Wl,-dynamic-linker -Wl,~a/~a \"$@\"~%"
   ;; This package must be public because other modules refer to it.  However,
   ;; mark it as hidden so that 'fold-packages' ignores it.
   (with-boot4 (hidden-package
-               (package-with-bootstrap-guile guile-2.2/fixed))))
+               (package-with-bootstrap-guile guile-3.0/fixed))))
 
 (define glibc-utf8-locales-final
   ;; Now that we have GUILE-FINAL, build the UTF-8 locales.  They are needed
@@ -2397,9 +3690,6 @@ exec ~a/bin/~a-~a -B~a/lib -Wl,-dynamic-linker -Wl,~a/~a \"$@\"~%"
 
 (define gnu-make-final
   ;; The final GNU Make, which uses the final Guile.
-  ;; FIXME: This is a mistake: we shouldn't be propagating GUILE-FINAL to
-  ;; PKG-CONFIG.
-  ;; TODO: Fix that on the next rebuild cycle.
   (let ((pkg-config (package
                       (inherit %pkg-config)       ;the native pkg-config
                       (inputs `(("guile" ,guile-final)
@@ -2420,7 +3710,10 @@ exec ~a/bin/~a-~a -B~a/lib -Wl,-dynamic-linker -Wl,~a/~a \"$@\"~%"
 (define coreutils-final
   ;; The final Coreutils.  Treat them specially because some packages, such as
   ;; Findutils, keep a reference to the Coreutils they were built with.
-  (with-boot5 (package-with-bootstrap-guile coreutils)
+  (with-boot5 (package-with-bootstrap-guile
+               (package
+                 (inherit coreutils-minimal)
+                 (name "coreutils")))
               ;; Use the final Guile, linked against the
               ;; final libc with working iconv, so that
               ;; 'substitute*' works well when touching