gnu/packages/bootstrap.scm

   1 ;;; GNU Guix --- Functional package management for GNU
   2 ;;; Copyright © 2012, 2013, 2014, 2015, 2016, 2017, 2018 Ludovic Courtès <ludo@gnu.org>
   3 ;;; Copyright © 2014, 2015, 2018 Mark H Weaver <mhw@netris.org>
   4 ;;; Copyright © 2017 Efraim Flashner <efraim@flashner.co.il>
   5 ;;;
   6 ;;; This file is part of GNU Guix.
   7 ;;;
   8 ;;; GNU Guix is free software; you can redistribute it and/or modify it
   9 ;;; under the terms of the GNU General Public License as published by
  10 ;;; the Free Software Foundation; either version 3 of the License, or (at
  11 ;;; your option) any later version.
  12 ;;;
  13 ;;; GNU Guix is distributed in the hope that it will be useful, but
  14 ;;; WITHOUT ANY WARRANTY; without even the implied warranty of
  15 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 ;;; GNU General Public License for more details.
  17 ;;;
  18 ;;; You should have received a copy of the GNU General Public License
  19 ;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.
  20
  21 (define-module (gnu packages bootstrap)
  22   #:use-module (guix licenses)
  23   #:use-module (gnu packages)
  24   #:use-module (guix packages)
  25   #:use-module (guix download)
  26   #:use-module (guix build-system)
  27   #:use-module (guix build-system gnu)
  28   #:use-module (guix build-system trivial)
  29   #:use-module ((guix store)
  30                 #:select (run-with-store add-to-store add-text-to-store))
  31   #:use-module ((guix derivations)
  32                 #:select (derivation derivation->output-path))
  33   #:use-module ((guix utils) #:select (gnu-triplet->nix-system))
  34   #:use-module (guix memoization)
  35   #:use-module (srfi srfi-1)
  36   #:use-module (srfi srfi-26)
  37   #:use-module (ice-9 match)
  38   #:export (bootstrap-origin
  39             package-with-bootstrap-guile
  40             glibc-dynamic-linker
  41
  42             bootstrap-guile-origin
  43
  44             %bootstrap-guile
  45             %bootstrap-coreutils&co
  46             %bootstrap-binutils
  47             %bootstrap-gcc
  48             %bootstrap-glibc
  49             %bootstrap-inputs))
  50
  51 ;;; Commentary:
  52 ;;;
  53 ;;; Pre-built packages that are used to bootstrap the
  54 ;;; distribution--i.e., to build all the core packages from scratch.
  55 ;;;
  56 ;;; Code:
  57
  58
  59 \f
  60 ;;;
  61 ;;; Helper procedures.
  62 ;;;
  63
  64 (define (bootstrap-origin source)
  65   "Return a variant of SOURCE, an <origin> instance, whose method uses
  66 %BOOTSTRAP-GUILE to do its job."
  67   (define (boot fetch)
  68     (lambda* (url hash-algo hash
  69               #:optional name #:key system)
  70       (fetch url hash-algo hash name
  71              #:guile %bootstrap-guile
  72              #:system system)))
  73
  74   (define %bootstrap-patch-inputs
  75     ;; Packages used when an <origin> has a non-empty 'patches' field.
  76     `(("tar"   ,%bootstrap-coreutils&co)
  77       ("xz"    ,%bootstrap-coreutils&co)
  78       ("bzip2" ,%bootstrap-coreutils&co)
  79       ("gzip"  ,%bootstrap-coreutils&co)
  80       ("patch" ,%bootstrap-coreutils&co)))
  81
  82   (let ((orig-method (origin-method source)))
  83     (origin (inherit source)
  84       (method (cond ((eq? orig-method url-fetch)
  85                      (boot url-fetch))
  86                     (else orig-method)))
  87       (patch-guile %bootstrap-guile)
  88       (patch-inputs %bootstrap-patch-inputs)
  89
  90       ;; Patches can be origins as well, so process them.
  91       (patches (map (match-lambda
  92                      ((? origin? patch)
  93                       (bootstrap-origin patch))
  94                      (patch patch))
  95                     (origin-patches source))))))
  96
  97 (define* (package-from-tarball name source program-to-test description
  98                                #:key snippet)
  99   "Return a package that correspond to the extraction of SOURCE.
 100 PROGRAM-TO-TEST is a program to run after extraction of SOURCE, to check
 101 whether everything is alright.  If SNIPPET is provided, it is evaluated after
 102 extracting SOURCE.  SNIPPET should raise an exception to signal an error; its
 103 return value is ignored."
 104   (package
 105     (name name)
 106     (version "0")
 107     (build-system trivial-build-system)
 108     (arguments
 109      `(#:guile ,%bootstrap-guile
 110        #:modules ((guix build utils))
 111        #:builder
 112        (let ((out     (assoc-ref %outputs "out"))
 113              (tar     (assoc-ref %build-inputs "tar"))
 114              (xz      (assoc-ref %build-inputs "xz"))
 115              (tarball (assoc-ref %build-inputs "tarball")))
 116          (use-modules (guix build utils))
 117
 118          (mkdir out)
 119          (copy-file tarball "binaries.tar.xz")
 120          (invoke xz "-d" "binaries.tar.xz")
 121          (let ((builddir (getcwd)))
 122            (with-directory-excursion out
 123              (invoke tar "xvf"
 124                      (string-append builddir "/binaries.tar"))
 125              ,@(if snippet (list snippet) '())
 126              (invoke (string-append "bin/" ,program-to-test)
 127                      "--version"))))))
 128     (inputs
 129      `(("tar" ,(search-bootstrap-binary "tar" (%current-system)))
 130        ("xz"  ,(search-bootstrap-binary "xz" (%current-system)))
 131        ("tarball" ,(bootstrap-origin (source (%current-system))))))
 132     (source #f)
 133     (synopsis description)
 134     (description description)
 135     (home-page #f)
 136     (license gpl3+)))
 137
 138 (define package-with-bootstrap-guile
 139   (mlambdaq (p)
 140     "Return a variant of P such that all its origins are fetched with
 141 %BOOTSTRAP-GUILE."
 142     (define rewritten-input
 143       (match-lambda
 144         ((name (? origin? o))
 145          `(,name ,(bootstrap-origin o)))
 146         ((name (? package? p) sub-drvs ...)
 147          `(,name ,(package-with-bootstrap-guile p) ,@sub-drvs))
 148         (x x)))
 149
 150     (package (inherit p)
 151              (source (match (package-source p)
 152                        ((? origin? o) (bootstrap-origin o))
 153                        (s s)))
 154              (inputs (map rewritten-input
 155                           (package-inputs p)))
 156              (native-inputs (map rewritten-input
 157                                  (package-native-inputs p)))
 158              (propagated-inputs (map rewritten-input
 159                                      (package-propagated-inputs p)))
 160              (replacement (and=> (package-replacement p)
 161                                  package-with-bootstrap-guile)))))
 162
 163 (define* (glibc-dynamic-linker
 164           #:optional (system (or (and=> (%current-target-system)
 165                                         gnu-triplet->nix-system)
 166                                  (%current-system))))
 167   "Return the name of Glibc's dynamic linker for SYSTEM."
 168   ;; See the 'SYSDEP_KNOWN_INTERPRETER_NAMES' cpp macro in libc.
 169   (cond ((string=? system "x86_64-linux") "/lib/ld-linux-x86-64.so.2")
 170         ((string=? system "i686-linux") "/lib/ld-linux.so.2")
 171         ((string=? system "armhf-linux") "/lib/ld-linux-armhf.so.3")
 172         ((string=? system "mips64el-linux") "/lib/ld.so.1")
 173         ((string=? system "i586-gnu") "/lib/ld.so.1")
 174         ((string=? system "i686-gnu") "/lib/ld.so.1")
 175         ((string=? system "aarch64-linux") "/lib/ld-linux-aarch64.so.1")
 176         ((string=? system "powerpc-linux") "/lib/ld.so.1")
 177         ((string=? system "powerpc64le-linux") "/lib/ld64.so.2")
 178         ((string=? system "alpha-linux") "/lib/ld-linux.so.2")
 179         ((string=? system "s390x-linux") "/lib/ld64.so.1")
 180         ((string=? system "riscv64-linux") "/lib/ld-linux-riscv64-lp64d.so.1")
 181
 182         ;; XXX: This one is used bare-bones, without a libc, so add a case
 183         ;; here just so we can keep going.
 184         ((string=? system "arm-elf") "no-ld.so")
 185         ((string=? system "arm-eabi") "no-ld.so")
 186         ((string=? system "xtensa-elf") "no-ld.so")
 187         ((string=? system "avr") "no-ld.so")
 188         ((string=? system "propeller-elf") "no-ld.so")
 189         ((string=? system "i686-mingw") "no-ld.so")
 190         ((string=? system "vc4-elf") "no-ld.so")
 191
 192         (else (error "dynamic linker name not known for this system"
 193                      system))))
 194
 195 \f
 196 ;;;
 197 ;;; Bootstrap packages.
 198 ;;;
 199
 200 (define %bootstrap-base-urls
 201   ;; This is where the initial binaries come from.
 202   '("https://alpha.gnu.org/gnu/guix/bootstrap"
 203     "http://alpha.gnu.org/gnu/guix/bootstrap"
 204     "ftp://alpha.gnu.org/gnu/guix/bootstrap"
 205     "http://www.fdn.fr/~lcourtes/software/guix/packages"
 206     "http://flashner.co.il/guix/bootstrap"))
 207
 208 (define (bootstrap-guile-url-path system)
 209   "Return the URI for FILE."
 210   (string-append "/" system
 211                  (match system
 212                    ("aarch64-linux"
 213                     "/20170217/guile-2.0.14.tar.xz")
 214                    ("armhf-linux"
 215                     "/20150101/guile-2.0.11.tar.xz")
 216                    (_
 217                     "/20131110/guile-2.0.9.tar.xz"))))
 218
 219 (define (bootstrap-guile-hash system)
 220   "Return the SHA256 hash of the Guile bootstrap tarball for SYSTEM."
 221   (match system
 222     ("x86_64-linux"
 223      (base32 "1w2p5zyrglzzniqgvyn1b55vprfzhgk8vzbzkkbdgl5248si0yq3"))
 224     ("i686-linux"
 225      (base32 "0im800m30abgh7msh331pcbjvb4n02smz5cfzf1srv0kpx3csmxp"))
 226     ("mips64el-linux"
 227      (base32 "0fzp93lvi0hn54acc0fpvhc7bvl0yc853k62l958cihk03q80ilr"))
 228     ("armhf-linux"
 229      (base32 "1mi3brl7l58aww34rawhvja84xc7l1b4hmwdmc36fp9q9mfx0lg5"))
 230     ("aarch64-linux"
 231      (base32 "1giy2aprjmn5fp9c4s9r125fljw4wv6ixy5739i5bffw4jgr0f9r"))))
 232
 233 (define (bootstrap-guile-origin system)
 234   "Return an <origin> object for the Guile tarball of SYSTEM."
 235   (origin
 236     (method url-fetch)
 237     (uri (map (cute string-append <> (bootstrap-guile-url-path system))
 238               %bootstrap-base-urls))
 239     (sha256 (bootstrap-guile-hash system))))
 240
 241 (define (download-bootstrap-guile store system)
 242   "Return a derivation that downloads the bootstrap Guile tarball for SYSTEM."
 243   (let* ((path (bootstrap-guile-url-path system))
 244          (base (basename path))
 245          (urls (map (cut string-append <> path) %bootstrap-base-urls)))
 246     (run-with-store store
 247       (url-fetch urls 'sha256 (bootstrap-guile-hash system)
 248                  #:system system))))
 249
 250 (define* (raw-build store name inputs
 251                     #:key outputs system search-paths
 252                     #:allow-other-keys)
 253   (define (->store file)
 254     (add-to-store store file #t "sha256"
 255                   (or (search-bootstrap-binary file
 256                                                system)
 257                       (error "bootstrap binary not found"
 258                              file system))))
 259
 260   (let* ((tar   (->store "tar"))
 261          (xz    (->store "xz"))
 262          (mkdir (->store "mkdir"))
 263          (bash  (->store "bash"))
 264          (guile (download-bootstrap-guile store system))
 265          ;; The following code, run by the bootstrap guile after it is
 266          ;; unpacked, creates a wrapper for itself to set its load path.
 267          ;; This replaces the previous non-portable method based on
 268          ;; reading the /proc/self/exe symlink.
 269          (make-guile-wrapper
 270           '(begin
 271              (use-modules (ice-9 match))
 272              (match (command-line)
 273                ((_ out bash)
 274                 (let ((bin-dir    (string-append out "/bin"))
 275                       (guile      (string-append out "/bin/guile"))
 276                       (guile-real (string-append out "/bin/.guile-real"))
 277                       ;; We must avoid using a bare dollar sign in this code,
 278                       ;; because it would be interpreted by the shell.
 279                       (dollar     (string (integer->char 36))))
 280                   (chmod bin-dir #o755)
 281                   (rename-file guile guile-real)
 282                   (call-with-output-file guile
 283                     (lambda (p)
 284                       (format p "\
 285 #!~a
 286 export GUILE_SYSTEM_PATH=~a/share/guile/2.0
 287 export GUILE_SYSTEM_COMPILED_PATH=~a/lib/guile/2.0/ccache
 288 exec -a \"~a0\" ~a \"~a@\"\n"
 289                               bash out out dollar guile-real dollar)))
 290                   (chmod guile   #o555)
 291                   (chmod bin-dir #o555))))))
 292          (builder
 293           (add-text-to-store store
 294                              "build-bootstrap-guile.sh"
 295                              (format #f "
 296 echo \"unpacking bootstrap Guile to '$out'...\"
 297 ~a $out
 298 cd $out
 299 ~a -dc < $GUILE_TARBALL | ~a xv
 300
 301 # Use the bootstrap guile to create its own wrapper to set the load path.
 302 GUILE_SYSTEM_PATH=$out/share/guile/2.0 \
 303 GUILE_SYSTEM_COMPILED_PATH=$out/lib/guile/2.0/ccache \
 304 $out/bin/guile -c ~s $out ~a
 305
 306 # Sanity check.
 307 $out/bin/guile --version~%"
 308                                      mkdir xz tar
 309                                      (format #f "~s" make-guile-wrapper)
 310                                      bash)
 311                              (list mkdir xz tar bash))))
 312     (derivation store name
 313                 bash `(,builder)
 314                 #:system system
 315                 #:inputs `((,bash) (,builder) (,guile))
 316                 #:env-vars `(("GUILE_TARBALL"
 317                               . ,(derivation->output-path guile))))))
 318
 319 (define* (make-raw-bag name
 320                        #:key source inputs native-inputs outputs
 321                        system target)
 322   (bag
 323     (name name)
 324     (system system)
 325     (build-inputs inputs)
 326     (build raw-build)))
 327
 328 (define %bootstrap-guile
 329   ;; The Guile used to run the build scripts of the initial derivations.
 330   ;; It is just unpacked from a tarball containing a pre-built binary.
 331   ;; This is typically built using %GUILE-BOOTSTRAP-TARBALL below.
 332   ;;
 333   ;; XXX: Would need libc's `libnss_files2.so' for proper `getaddrinfo'
 334   ;; support (for /etc/services).
 335   (let ((raw (build-system
 336                (name 'raw)
 337                (description "Raw build system with direct store access")
 338                (lower make-raw-bag))))
 339    (package
 340      (name "guile-bootstrap")
 341      (version "2.0")
 342      (source #f)
 343      (build-system raw)
 344      (synopsis "Bootstrap Guile")
 345      (description "Pre-built Guile for bootstrapping purposes.")
 346      (home-page #f)
 347      (license lgpl3+))))
 348
 349 (define %bootstrap-coreutils&co
 350   (package-from-tarball "bootstrap-binaries"
 351                         (lambda (system)
 352                           (origin
 353                            (method url-fetch)
 354                            (uri (map (cut string-append <> "/" system
 355                                           (match system
 356                                             ("armhf-linux"
 357                                              "/20150101/static-binaries.tar.xz")
 358                                             ("aarch64-linux"
 359                                              "/20170217/static-binaries.tar.xz")
 360                                             (_
 361                                              "/20131110/static-binaries.tar.xz")))
 362                                      %bootstrap-base-urls))
 363                            (sha256
 364                             (match system
 365                               ("x86_64-linux"
 366                                (base32
 367                                 "0c533p9dhczzcsa1117gmfq3pc8w362g4mx84ik36srpr7cx2bg4"))
 368                               ("i686-linux"
 369                                (base32
 370                                 "0s5b3jb315n13m1k8095l0a5hfrsz8g0fv1b6riyc5hnxqyphlak"))
 371                               ("armhf-linux"
 372                                (base32
 373                                 "0gf0fn2kbpxkjixkmx5f4z6hv6qpmgixl69zgg74dbsfdfj8jdv5"))
 374                               ("aarch64-linux"
 375                                (base32
 376                                 "18dfiq6c6xhsdpbidigw6480wh0vdgsxqq3xindq4lpdgqlccpfh"))
 377                               ("mips64el-linux"
 378                                (base32
 379                                 "072y4wyfsj1bs80r6vbybbafy8ya4vfy7qj25dklwk97m6g71753"))))))
 380                         "fgrep"                    ; the program to test
 381                         "Bootstrap binaries of Coreutils, Awk, etc."
 382                         #:snippet
 383                         '(let ((path (list (string-append (getcwd) "/bin"))))
 384                            (chmod "bin" #o755)
 385                            (patch-shebang "bin/egrep" path)
 386                            (patch-shebang "bin/fgrep" path)
 387                            ;; Starting with grep@2.25 'egrep' and 'fgrep' are shell files
 388                            ;; that call 'grep'.  If the bootstrap 'egrep' and 'fgrep'
 389                            ;; are not binaries then patch them to execute 'grep' via its
 390                            ;; absolute file name instead of searching for it in $PATH.
 391                            (if (not (elf-file? "bin/egrep"))
 392                              (substitute* '("bin/egrep" "bin/fgrep")
 393                                (("^exec grep") (string-append (getcwd) "/bin/grep"))))
 394                            (chmod "bin" #o555))))
 395
 396 (define %bootstrap-binutils
 397   (package-from-tarball "binutils-bootstrap"
 398                         (lambda (system)
 399                           (origin
 400                            (method url-fetch)
 401                            (uri (map (cut string-append <> "/" system
 402                                           (match system
 403                                             ("armhf-linux"
 404                                              "/20150101/binutils-2.25.tar.xz")
 405                                             ("aarch64-linux"
 406                                              "/20170217/binutils-2.27.tar.xz")
 407                                             (_
 408                                              "/20131110/binutils-2.23.2.tar.xz")))
 409                                      %bootstrap-base-urls))
 410                            (sha256
 411                             (match system
 412                               ("x86_64-linux"
 413                                (base32
 414                                 "1j5yivz7zkjqfsfmxzrrrffwyayjqyfxgpi89df0w4qziqs2dg20"))
 415                               ("i686-linux"
 416                                (base32
 417                                 "14jgwf9gscd7l2pnz610b1zia06dvcm2qyzvni31b8zpgmcai2v9"))
 418                               ("armhf-linux"
 419                                (base32
 420                                 "1v7dj6bzn6m36f20gw31l99xaabq4xrhrx3gwqkhhig0mdlmr69q"))
 421                               ("aarch64-linux"
 422                                (base32
 423                                 "111s7ilfiby033rczc71797xrmaa3qlv179wdvsaq132pd51xv3n"))
 424                               ("mips64el-linux"
 425                                (base32
 426                                 "1x8kkhcxmfyzg1ddpz2pxs6fbdl6412r7x0nzbmi5n7mj8zw2gy7"))))))
 427                         "ld"                      ; the program to test
 428                         "Bootstrap binaries of the GNU Binutils"))
 429
 430 (define %bootstrap-glibc
 431   ;; The initial libc.
 432   (package
 433     (name "glibc-bootstrap")
 434     (version "0")
 435     (source #f)
 436     (build-system trivial-build-system)
 437     (arguments
 438      `(#:guile ,%bootstrap-guile
 439        #:modules ((guix build utils))
 440        #:builder
 441        (let ((out     (assoc-ref %outputs "out"))
 442              (tar     (assoc-ref %build-inputs "tar"))
 443              (xz      (assoc-ref %build-inputs "xz"))
 444              (tarball (assoc-ref %build-inputs "tarball")))
 445          (use-modules (guix build utils))
 446
 447          (mkdir out)
 448          (copy-file tarball "binaries.tar.xz")
 449          (invoke xz "-d" "binaries.tar.xz")
 450          (let ((builddir (getcwd)))
 451            (with-directory-excursion out
 452              (invoke tar "xvf"
 453                      (string-append builddir
 454                                     "/binaries.tar"))
 455              (chmod "lib" #o755)
 456
 457              ;; Patch libc.so so it refers to the right path.
 458              (substitute* "lib/libc.so"
 459                (("/[^ ]+/lib/(libc|ld)" _ prefix)
 460                 (string-append out "/lib/" prefix)))
 461
 462              #t)))))
 463     (inputs
 464      `(("tar" ,(search-bootstrap-binary "tar" (%current-system)))
 465        ("xz"  ,(search-bootstrap-binary "xz" (%current-system)))
 466        ("tarball" ,(bootstrap-origin
 467                     (origin
 468                      (method url-fetch)
 469                      (uri (map (cut string-append <> "/" (%current-system)
 470                                     (match (%current-system)
 471                                       ("armhf-linux"
 472                                        "/20150101/glibc-2.20.tar.xz")
 473                                       ("aarch64-linux"
 474                                        "/20170217/glibc-2.25.tar.xz")
 475                                       (_
 476                                        "/20131110/glibc-2.18.tar.xz")))
 477                                %bootstrap-base-urls))
 478                      (sha256
 479                       (match (%current-system)
 480                         ("x86_64-linux"
 481                          (base32
 482                           "0jlqrgavvnplj1b083s20jj9iddr4lzfvwybw5xrcis9spbfzk7v"))
 483                         ("i686-linux"
 484                          (base32
 485                           "1hgrccw1zqdc7lvgivwa54d9l3zsim5pqm0dykxg0z522h6gr05w"))
 486                         ("armhf-linux"
 487                          (base32
 488                           "18cmgvpllqfpn6khsmivqib7ys8ymnq0hdzi3qp24prik0ykz8gn"))
 489                         ("aarch64-linux"
 490                          (base32
 491                           "07nx3x8598i2924rjnlrncg6rm61c9bmcczbbcpbx0fb742nvv5c"))
 492                         ("mips64el-linux"
 493                          (base32
 494                           "0k97a3whzx3apsi9n2cbsrr79ad6lh00klxph9hw4fqyp1abkdsg")))))))))
 495     (synopsis "Bootstrap binaries and headers of the GNU C Library")
 496     (description synopsis)
 497     (home-page #f)
 498     (license lgpl2.1+)))
 499
 500 (define %bootstrap-gcc
 501   ;; The initial GCC.  Uses binaries from a tarball typically built by
 502   ;; %GCC-BOOTSTRAP-TARBALL.
 503   (package
 504     (name "gcc-bootstrap")
 505     (version "0")
 506     (source #f)
 507     (build-system trivial-build-system)
 508     (arguments
 509      `(#:guile ,%bootstrap-guile
 510        #:modules ((guix build utils))
 511        #:builder
 512        (let ((out     (assoc-ref %outputs "out"))
 513              (tar     (assoc-ref %build-inputs "tar"))
 514              (xz      (assoc-ref %build-inputs "xz"))
 515              (bash    (assoc-ref %build-inputs "bash"))
 516              (libc    (assoc-ref %build-inputs "libc"))
 517              (tarball (assoc-ref %build-inputs "tarball")))
 518          (use-modules (guix build utils)
 519                       (ice-9 popen))
 520
 521          (mkdir out)
 522          (copy-file tarball "binaries.tar.xz")
 523          (invoke xz "-d" "binaries.tar.xz")
 524          (let ((builddir (getcwd))
 525                (bindir   (string-append out "/bin")))
 526            (with-directory-excursion out
 527              (invoke tar "xvf"
 528                      (string-append builddir "/binaries.tar")))
 529
 530            (with-directory-excursion bindir
 531              (chmod "." #o755)
 532              (rename-file "gcc" ".gcc-wrapped")
 533              (call-with-output-file "gcc"
 534                (lambda (p)
 535                  (format p "#!~a
 536 exec ~a/bin/.gcc-wrapped -B~a/lib \
 537      -Wl,-rpath -Wl,~a/lib \
 538      -Wl,-dynamic-linker -Wl,~a/~a \"$@\"~%"
 539                          bash
 540                          out libc libc libc
 541                          ,(glibc-dynamic-linker))))
 542
 543              (chmod "gcc" #o555)
 544              #t)))))
 545     (inputs
 546      `(("tar" ,(search-bootstrap-binary "tar" (%current-system)))
 547        ("xz"  ,(search-bootstrap-binary "xz" (%current-system)))
 548        ("bash" ,(search-bootstrap-binary "bash" (%current-system)))
 549        ("libc" ,%bootstrap-glibc)
 550        ("tarball" ,(bootstrap-origin
 551                     (origin
 552                      (method url-fetch)
 553                      (uri (map (cut string-append <> "/" (%current-system)
 554                                     (match (%current-system)
 555                                       ("armhf-linux"
 556                                        "/20150101/gcc-4.8.4.tar.xz")
 557                                       ("aarch64-linux"
 558                                        "/20170217/gcc-5.4.0.tar.xz")
 559                                       (_
 560                                        "/20131110/gcc-4.8.2.tar.xz")))
 561                                %bootstrap-base-urls))
 562                      (sha256
 563                       (match (%current-system)
 564                         ("x86_64-linux"
 565                          (base32
 566                           "17ga4m6195n4fnbzdkmik834znkhs53nkypp6557pl1ps7dgqbls"))
 567                         ("i686-linux"
 568                          (base32
 569                           "150c1arrf2k8vfy6dpxh59vcgs4p1bgiz2av5m19dynpks7rjnyw"))
 570                         ("armhf-linux"
 571                          (base32
 572                           "0ghz825yzp43fxw53kd6afm8nkz16f7dxi9xi40bfwc8x3nbbr8v"))
 573                         ("aarch64-linux"
 574                          (base32
 575                           "1ar3vdzyqbfm0z36kmvazvfswxhcihlacl2dzdjgiq25cqnq9ih1"))
 576                         ("mips64el-linux"
 577                          (base32
 578                           "1m5miqkyng45l745n0sfafdpjkqv9225xf44jqkygwsipj2cv9ks")))))))))
 579     (native-search-paths
 580      (list (search-path-specification
 581             (variable "CPATH")
 582             (files '("include")))
 583            (search-path-specification
 584             (variable "LIBRARY_PATH")
 585             (files '("lib" "lib64")))))
 586     (synopsis "Bootstrap binaries of the GNU Compiler Collection")
 587     (description synopsis)
 588     (home-page #f)
 589     (license gpl3+)))
 590
 591 (define %bootstrap-inputs
 592   ;; The initial, pre-built inputs.  From now on, we can start building our
 593   ;; own packages.
 594   `(("libc" ,%bootstrap-glibc)
 595     ("gcc" ,%bootstrap-gcc)
 596     ("binutils" ,%bootstrap-binutils)
 597     ("coreutils&co" ,%bootstrap-coreutils&co)
 598
 599     ;; In gnu-build-system.scm, we rely on the availability of Bash.
 600     ("bash" ,%bootstrap-coreutils&co)))
 601
 602 ;;; bootstrap.scm ends here