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
 181         ;; XXX: This one is used bare-bones, without a libc, so add a case
 182         ;; here just so we can keep going.
 183         ((string=? system "arm-elf") "no-ld.so")
 184         ((string=? system "arm-eabi") "no-ld.so")
 185         ((string=? system "xtensa-elf") "no-ld.so")
 186         ((string=? system "avr") "no-ld.so")
 187         ((string=? system "propeller-elf") "no-ld.so")
 188         ((string=? system "i686-mingw") "no-ld.so")
 189         ((string=? system "vc4-elf") "no-ld.so")
 190
 191         (else (error "dynamic linker name not known for this system"
 192                      system))))
 193
 194 \f
 195 ;;;
 196 ;;; Bootstrap packages.
 197 ;;;
 198
 199 (define %bootstrap-base-urls
 200   ;; This is where the initial binaries come from.
 201   '("https://alpha.gnu.org/gnu/guix/bootstrap"
 202     "http://alpha.gnu.org/gnu/guix/bootstrap"
 203     "ftp://alpha.gnu.org/gnu/guix/bootstrap"
 204     "http://www.fdn.fr/~lcourtes/software/guix/packages"
 205     "http://flashner.co.il/guix/bootstrap"))
 206
 207 (define (bootstrap-guile-url-path system)
 208   "Return the URI for FILE."
 209   (string-append "/" system
 210                  (match system
 211                    ("aarch64-linux"
 212                     "/20170217/guile-2.0.14.tar.xz")
 213                    ("armhf-linux"
 214                     "/20150101/guile-2.0.11.tar.xz")
 215                    (_
 216                     "/20131110/guile-2.0.9.tar.xz"))))
 217
 218 (define (bootstrap-guile-hash system)
 219   "Return the SHA256 hash of the Guile bootstrap tarball for SYSTEM."
 220   (match system
 221     ("x86_64-linux"
 222      (base32 "1w2p5zyrglzzniqgvyn1b55vprfzhgk8vzbzkkbdgl5248si0yq3"))
 223     ("i686-linux"
 224      (base32 "0im800m30abgh7msh331pcbjvb4n02smz5cfzf1srv0kpx3csmxp"))
 225     ("mips64el-linux"
 226      (base32 "0fzp93lvi0hn54acc0fpvhc7bvl0yc853k62l958cihk03q80ilr"))
 227     ("armhf-linux"
 228      (base32 "1mi3brl7l58aww34rawhvja84xc7l1b4hmwdmc36fp9q9mfx0lg5"))
 229     ("aarch64-linux"
 230      (base32 "1giy2aprjmn5fp9c4s9r125fljw4wv6ixy5739i5bffw4jgr0f9r"))))
 231
 232 (define (bootstrap-guile-origin system)
 233   "Return an <origin> object for the Guile tarball of SYSTEM."
 234   (origin
 235     (method url-fetch)
 236     (uri (map (cute string-append <> (bootstrap-guile-url-path system))
 237               %bootstrap-base-urls))
 238     (sha256 (bootstrap-guile-hash system))))
 239
 240 (define (download-bootstrap-guile store system)
 241   "Return a derivation that downloads the bootstrap Guile tarball for SYSTEM."
 242   (let* ((path (bootstrap-guile-url-path system))
 243          (base (basename path))
 244          (urls (map (cut string-append <> path) %bootstrap-base-urls)))
 245     (run-with-store store
 246       (url-fetch urls 'sha256 (bootstrap-guile-hash system)
 247                  #:system system))))
 248
 249 (define* (raw-build store name inputs
 250                     #:key outputs system search-paths
 251                     #:allow-other-keys)
 252   (define (->store file)
 253     (add-to-store store file #t "sha256"
 254                   (or (search-bootstrap-binary file
 255                                                system)
 256                       (error "bootstrap binary not found"
 257                              file system))))
 258
 259   (let* ((tar   (->store "tar"))
 260          (xz    (->store "xz"))
 261          (mkdir (->store "mkdir"))
 262          (bash  (->store "bash"))
 263          (guile (download-bootstrap-guile store system))
 264          ;; The following code, run by the bootstrap guile after it is
 265          ;; unpacked, creates a wrapper for itself to set its load path.
 266          ;; This replaces the previous non-portable method based on
 267          ;; reading the /proc/self/exe symlink.
 268          (make-guile-wrapper
 269           '(begin
 270              (use-modules (ice-9 match))
 271              (match (command-line)
 272                ((_ out bash)
 273                 (let ((bin-dir    (string-append out "/bin"))
 274                       (guile      (string-append out "/bin/guile"))
 275                       (guile-real (string-append out "/bin/.guile-real"))
 276                       ;; We must avoid using a bare dollar sign in this code,
 277                       ;; because it would be interpreted by the shell.
 278                       (dollar     (string (integer->char 36))))
 279                   (chmod bin-dir #o755)
 280                   (rename-file guile guile-real)
 281                   (call-with-output-file guile
 282                     (lambda (p)
 283                       (format p "\
 284 #!~a
 285 export GUILE_SYSTEM_PATH=~a/share/guile/2.0
 286 export GUILE_SYSTEM_COMPILED_PATH=~a/lib/guile/2.0/ccache
 287 exec -a \"~a0\" ~a \"~a@\"\n"
 288                               bash out out dollar guile-real dollar)))
 289                   (chmod guile   #o555)
 290                   (chmod bin-dir #o555))))))
 291          (builder
 292           (add-text-to-store store
 293                              "build-bootstrap-guile.sh"
 294                              (format #f "
 295 echo \"unpacking bootstrap Guile to '$out'...\"
 296 ~a $out
 297 cd $out
 298 ~a -dc < $GUILE_TARBALL | ~a xv
 299
 300 # Use the bootstrap guile to create its own wrapper to set the load path.
 301 GUILE_SYSTEM_PATH=$out/share/guile/2.0 \
 302 GUILE_SYSTEM_COMPILED_PATH=$out/lib/guile/2.0/ccache \
 303 $out/bin/guile -c ~s $out ~a
 304
 305 # Sanity check.
 306 $out/bin/guile --version~%"
 307                                      mkdir xz tar
 308                                      (format #f "~s" make-guile-wrapper)
 309                                      bash)
 310                              (list mkdir xz tar bash))))
 311     (derivation store name
 312                 bash `(,builder)
 313                 #:system system
 314                 #:inputs `((,bash) (,builder) (,guile))
 315                 #:env-vars `(("GUILE_TARBALL"
 316                               . ,(derivation->output-path guile))))))
 317
 318 (define* (make-raw-bag name
 319                        #:key source inputs native-inputs outputs
 320                        system target)
 321   (bag
 322     (name name)
 323     (system system)
 324     (build-inputs inputs)
 325     (build raw-build)))
 326
 327 (define %bootstrap-guile
 328   ;; The Guile used to run the build scripts of the initial derivations.
 329   ;; It is just unpacked from a tarball containing a pre-built binary.
 330   ;; This is typically built using %GUILE-BOOTSTRAP-TARBALL below.
 331   ;;
 332   ;; XXX: Would need libc's `libnss_files2.so' for proper `getaddrinfo'
 333   ;; support (for /etc/services).
 334   (let ((raw (build-system
 335                (name 'raw)
 336                (description "Raw build system with direct store access")
 337                (lower make-raw-bag))))
 338    (package
 339      (name "guile-bootstrap")
 340      (version "2.0")
 341      (source #f)
 342      (build-system raw)
 343      (synopsis "Bootstrap Guile")
 344      (description "Pre-built Guile for bootstrapping purposes.")
 345      (home-page #f)
 346      (license lgpl3+))))
 347
 348 (define %bootstrap-coreutils&co
 349   (package-from-tarball "bootstrap-binaries"
 350                         (lambda (system)
 351                           (origin
 352                            (method url-fetch)
 353                            (uri (map (cut string-append <> "/" system
 354                                           (match system
 355                                             ("armhf-linux"
 356                                              "/20150101/static-binaries.tar.xz")
 357                                             ("aarch64-linux"
 358                                              "/20170217/static-binaries.tar.xz")
 359                                             (_
 360                                              "/20131110/static-binaries.tar.xz")))
 361                                      %bootstrap-base-urls))
 362                            (sha256
 363                             (match system
 364                               ("x86_64-linux"
 365                                (base32
 366                                 "0c533p9dhczzcsa1117gmfq3pc8w362g4mx84ik36srpr7cx2bg4"))
 367                               ("i686-linux"
 368                                (base32
 369                                 "0s5b3jb315n13m1k8095l0a5hfrsz8g0fv1b6riyc5hnxqyphlak"))
 370                               ("armhf-linux"
 371                                (base32
 372                                 "0gf0fn2kbpxkjixkmx5f4z6hv6qpmgixl69zgg74dbsfdfj8jdv5"))
 373                               ("aarch64-linux"
 374                                (base32
 375                                 "18dfiq6c6xhsdpbidigw6480wh0vdgsxqq3xindq4lpdgqlccpfh"))
 376                               ("mips64el-linux"
 377                                (base32
 378                                 "072y4wyfsj1bs80r6vbybbafy8ya4vfy7qj25dklwk97m6g71753"))))))
 379                         "fgrep"                    ; the program to test
 380                         "Bootstrap binaries of Coreutils, Awk, etc."
 381                         #:snippet
 382                         '(let ((path (list (string-append (getcwd) "/bin"))))
 383                            (chmod "bin" #o755)
 384                            (patch-shebang "bin/egrep" path)
 385                            (patch-shebang "bin/fgrep" path)
 386                            ;; Starting with grep@2.25 'egrep' and 'fgrep' are shell files
 387                            ;; that call 'grep'.  If the bootstrap 'egrep' and 'fgrep'
 388                            ;; are not binaries then patch them to execute 'grep' via its
 389                            ;; absolute file name instead of searching for it in $PATH.
 390                            (if (not (elf-file? "bin/egrep"))
 391                              (substitute* '("bin/egrep" "bin/fgrep")
 392                                (("^exec grep") (string-append (getcwd) "/bin/grep"))))
 393                            (chmod "bin" #o555))))
 394
 395 (define %bootstrap-binutils
 396   (package-from-tarball "binutils-bootstrap"
 397                         (lambda (system)
 398                           (origin
 399                            (method url-fetch)
 400                            (uri (map (cut string-append <> "/" system
 401                                           (match system
 402                                             ("armhf-linux"
 403                                              "/20150101/binutils-2.25.tar.xz")
 404                                             ("aarch64-linux"
 405                                              "/20170217/binutils-2.27.tar.xz")
 406                                             (_
 407                                              "/20131110/binutils-2.23.2.tar.xz")))
 408                                      %bootstrap-base-urls))
 409                            (sha256
 410                             (match system
 411                               ("x86_64-linux"
 412                                (base32
 413                                 "1j5yivz7zkjqfsfmxzrrrffwyayjqyfxgpi89df0w4qziqs2dg20"))
 414                               ("i686-linux"
 415                                (base32
 416                                 "14jgwf9gscd7l2pnz610b1zia06dvcm2qyzvni31b8zpgmcai2v9"))
 417                               ("armhf-linux"
 418                                (base32
 419                                 "1v7dj6bzn6m36f20gw31l99xaabq4xrhrx3gwqkhhig0mdlmr69q"))
 420                               ("aarch64-linux"
 421                                (base32
 422                                 "111s7ilfiby033rczc71797xrmaa3qlv179wdvsaq132pd51xv3n"))
 423                               ("mips64el-linux"
 424                                (base32
 425                                 "1x8kkhcxmfyzg1ddpz2pxs6fbdl6412r7x0nzbmi5n7mj8zw2gy7"))))))
 426                         "ld"                      ; the program to test
 427                         "Bootstrap binaries of the GNU Binutils"))
 428
 429 (define %bootstrap-glibc
 430   ;; The initial libc.
 431   (package
 432     (name "glibc-bootstrap")
 433     (version "0")
 434     (source #f)
 435     (build-system trivial-build-system)
 436     (arguments
 437      `(#:guile ,%bootstrap-guile
 438        #:modules ((guix build utils))
 439        #:builder
 440        (let ((out     (assoc-ref %outputs "out"))
 441              (tar     (assoc-ref %build-inputs "tar"))
 442              (xz      (assoc-ref %build-inputs "xz"))
 443              (tarball (assoc-ref %build-inputs "tarball")))
 444          (use-modules (guix build utils))
 445
 446          (mkdir out)
 447          (copy-file tarball "binaries.tar.xz")
 448          (invoke xz "-d" "binaries.tar.xz")
 449          (let ((builddir (getcwd)))
 450            (with-directory-excursion out
 451              (invoke tar "xvf"
 452                      (string-append builddir
 453                                     "/binaries.tar"))
 454              (chmod "lib" #o755)
 455
 456              ;; Patch libc.so so it refers to the right path.
 457              (substitute* "lib/libc.so"
 458                (("/[^ ]+/lib/(libc|ld)" _ prefix)
 459                 (string-append out "/lib/" prefix)))
 460
 461              #t)))))
 462     (inputs
 463      `(("tar" ,(search-bootstrap-binary "tar" (%current-system)))
 464        ("xz"  ,(search-bootstrap-binary "xz" (%current-system)))
 465        ("tarball" ,(bootstrap-origin
 466                     (origin
 467                      (method url-fetch)
 468                      (uri (map (cut string-append <> "/" (%current-system)
 469                                     (match (%current-system)
 470                                       ("armhf-linux"
 471                                        "/20150101/glibc-2.20.tar.xz")
 472                                       ("aarch64-linux"
 473                                        "/20170217/glibc-2.25.tar.xz")
 474                                       (_
 475                                        "/20131110/glibc-2.18.tar.xz")))
 476                                %bootstrap-base-urls))
 477                      (sha256
 478                       (match (%current-system)
 479                         ("x86_64-linux"
 480                          (base32
 481                           "0jlqrgavvnplj1b083s20jj9iddr4lzfvwybw5xrcis9spbfzk7v"))
 482                         ("i686-linux"
 483                          (base32
 484                           "1hgrccw1zqdc7lvgivwa54d9l3zsim5pqm0dykxg0z522h6gr05w"))
 485                         ("armhf-linux"
 486                          (base32
 487                           "18cmgvpllqfpn6khsmivqib7ys8ymnq0hdzi3qp24prik0ykz8gn"))
 488                         ("aarch64-linux"
 489                          (base32
 490                           "07nx3x8598i2924rjnlrncg6rm61c9bmcczbbcpbx0fb742nvv5c"))
 491                         ("mips64el-linux"
 492                          (base32
 493                           "0k97a3whzx3apsi9n2cbsrr79ad6lh00klxph9hw4fqyp1abkdsg")))))))))
 494     (synopsis "Bootstrap binaries and headers of the GNU C Library")
 495     (description synopsis)
 496     (home-page #f)
 497     (license lgpl2.1+)))
 498
 499 (define %bootstrap-gcc
 500   ;; The initial GCC.  Uses binaries from a tarball typically built by
 501   ;; %GCC-BOOTSTRAP-TARBALL.
 502   (package
 503     (name "gcc-bootstrap")
 504     (version "0")
 505     (source #f)
 506     (build-system trivial-build-system)
 507     (arguments
 508      `(#:guile ,%bootstrap-guile
 509        #:modules ((guix build utils))
 510        #:builder
 511        (let ((out     (assoc-ref %outputs "out"))
 512              (tar     (assoc-ref %build-inputs "tar"))
 513              (xz      (assoc-ref %build-inputs "xz"))
 514              (bash    (assoc-ref %build-inputs "bash"))
 515              (libc    (assoc-ref %build-inputs "libc"))
 516              (tarball (assoc-ref %build-inputs "tarball")))
 517          (use-modules (guix build utils)
 518                       (ice-9 popen))
 519
 520          (mkdir out)
 521          (copy-file tarball "binaries.tar.xz")
 522          (invoke xz "-d" "binaries.tar.xz")
 523          (let ((builddir (getcwd))
 524                (bindir   (string-append out "/bin")))
 525            (with-directory-excursion out
 526              (invoke tar "xvf"
 527                      (string-append builddir "/binaries.tar")))
 528
 529            (with-directory-excursion bindir
 530              (chmod "." #o755)
 531              (rename-file "gcc" ".gcc-wrapped")
 532              (call-with-output-file "gcc"
 533                (lambda (p)
 534                  (format p "#!~a
 535 exec ~a/bin/.gcc-wrapped -B~a/lib \
 536      -Wl,-rpath -Wl,~a/lib \
 537      -Wl,-dynamic-linker -Wl,~a/~a \"$@\"~%"
 538                          bash
 539                          out libc libc libc
 540                          ,(glibc-dynamic-linker))))
 541
 542              (chmod "gcc" #o555)
 543              #t)))))
 544     (inputs
 545      `(("tar" ,(search-bootstrap-binary "tar" (%current-system)))
 546        ("xz"  ,(search-bootstrap-binary "xz" (%current-system)))
 547        ("bash" ,(search-bootstrap-binary "bash" (%current-system)))
 548        ("libc" ,%bootstrap-glibc)
 549        ("tarball" ,(bootstrap-origin
 550                     (origin
 551                      (method url-fetch)
 552                      (uri (map (cut string-append <> "/" (%current-system)
 553                                     (match (%current-system)
 554                                       ("armhf-linux"
 555                                        "/20150101/gcc-4.8.4.tar.xz")
 556                                       ("aarch64-linux"
 557                                        "/20170217/gcc-5.4.0.tar.xz")
 558                                       (_
 559                                        "/20131110/gcc-4.8.2.tar.xz")))
 560                                %bootstrap-base-urls))
 561                      (sha256
 562                       (match (%current-system)
 563                         ("x86_64-linux"
 564                          (base32
 565                           "17ga4m6195n4fnbzdkmik834znkhs53nkypp6557pl1ps7dgqbls"))
 566                         ("i686-linux"
 567                          (base32
 568                           "150c1arrf2k8vfy6dpxh59vcgs4p1bgiz2av5m19dynpks7rjnyw"))
 569                         ("armhf-linux"
 570                          (base32
 571                           "0ghz825yzp43fxw53kd6afm8nkz16f7dxi9xi40bfwc8x3nbbr8v"))
 572                         ("aarch64-linux"
 573                          (base32
 574                           "1ar3vdzyqbfm0z36kmvazvfswxhcihlacl2dzdjgiq25cqnq9ih1"))
 575                         ("mips64el-linux"
 576                          (base32
 577                           "1m5miqkyng45l745n0sfafdpjkqv9225xf44jqkygwsipj2cv9ks")))))))))
 578     (native-search-paths
 579      (list (search-path-specification
 580             (variable "CPATH")
 581             (files '("include")))
 582            (search-path-specification
 583             (variable "LIBRARY_PATH")
 584             (files '("lib" "lib64")))))
 585     (synopsis "Bootstrap binaries of the GNU Compiler Collection")
 586     (description synopsis)
 587     (home-page #f)
 588     (license gpl3+)))
 589
 590 (define %bootstrap-inputs
 591   ;; The initial, pre-built inputs.  From now on, we can start building our
 592   ;; own packages.
 593   `(("libc" ,%bootstrap-glibc)
 594     ("gcc" ,%bootstrap-gcc)
 595     ("binutils" ,%bootstrap-binutils)
 596     ("coreutils&co" ,%bootstrap-coreutils&co)
 597
 598     ;; In gnu-build-system.scm, we rely on the availability of Bash.
 599     ("bash" ,%bootstrap-coreutils&co)))
 600
 601 ;;; bootstrap.scm ends here