1 ;;; GNU Guix --- Functional package management for GNU
2 ;;; Copyright © 2013, 2014, 2015, 2016, 2017 Ludovic Courtès <ludo@gnu.org>
3 ;;; Copyright © 2014, 2015, 2018 Mark H Weaver <mhw@netris.org>
4 ;;; Copyright © 2016 Jan Nieuwenhuizen <janneke@gnu.org>
5 ;;; Copyright © 2016 Manolis Fragkiskos Ragkousis <manolis837@gmail.com>
6 ;;; Copyright © 2018 Tobias Geerinckx-Rice <me@tobias.gr>
8 ;;; This file is part of GNU Guix.
10 ;;; GNU Guix is free software; you can redistribute it and/or modify it
11 ;;; under the terms of the GNU General Public License as published by
12 ;;; the Free Software Foundation; either version 3 of the License, or (at
13 ;;; your option) any later version.
15 ;;; GNU Guix is distributed in the hope that it will be useful, but
16 ;;; WITHOUT ANY WARRANTY; without even the implied warranty of
17 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 ;;; GNU General Public License for more details.
20 ;;; You should have received a copy of the GNU General Public License
21 ;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>.
23 (define-module (gnu packages cross-base)
24 #:use-module (gnu packages)
25 #:use-module (gnu packages gcc)
26 #:use-module (gnu packages base)
27 #:use-module (gnu packages linux)
28 #:use-module (gnu packages hurd)
29 #:use-module (gnu packages mingw)
30 #:use-module (guix packages)
31 #:use-module (guix download)
32 #:use-module (guix utils)
33 #:use-module (guix build-system gnu)
34 #:use-module (guix build-system trivial)
35 #:use-module (srfi srfi-1)
36 #:use-module (srfi srfi-26)
37 #:use-module (ice-9 match)
38 #:use-module (ice-9 regex)
39 #:export (cross-binutils
45 ;; GCC package used as the basis for cross-compilation. It doesn't have to
46 ;; be 'gcc' and can be a specific variant such as 'gcc-4.8'.
48 ;; Note: This is a macro so that we do not refer to 'gcc' from the top
49 ;; level, which would lead to circular-dependency issues.
50 (identifier-syntax gcc))
52 (define %gcc-include-paths
53 ;; Environment variables for header search paths.
54 ;; Note: See <http://bugs.gnu.org/22186> for why not 'CPATH'.
58 "OBJCPLUS_INCLUDE_PATH"))
60 (define %gcc-cross-include-paths
61 ;; Search path for target headers when cross-compiling.
62 (map (cut string-append "CROSS_" <>) %gcc-include-paths))
64 (define (cross p target)
66 (name (string-append (package-name p) "-cross-" target))
68 (substitute-keyword-arguments (package-arguments p)
69 ((#:configure-flags flags)
70 `(cons ,(string-append "--target=" target)
73 (define (package-with-patch original patch)
74 "Return package ORIGINAL with PATCH applied."
75 (package (inherit original)
76 (source (origin (inherit (package-source original))
77 (patches (list patch))))))
79 (define (cross-binutils target)
80 "Return a cross-Binutils for TARGET."
81 (let ((binutils (package (inherit binutils)
83 (substitute-keyword-arguments (package-arguments
85 ((#:configure-flags flags)
86 ;; Build with `--with-sysroot' so that ld honors
87 ;; DT_RUNPATH entries when searching for a needed
88 ;; library. This works because as a side effect
89 ;; `genscripts.sh' sets `USE_LIBPATH=yes', which tells
90 ;; elf32.em to use DT_RUNPATH in its search list.
91 ;; See <http://sourceware.org/ml/binutils/2013-05/msg00312.html>.
93 ;; In theory choosing / as the sysroot could lead ld
94 ;; to pick up native libs instead of target ones. In
95 ;; practice the RUNPATH of target libs only refers to
96 ;; target libs, not native libs, so this is safe.
97 `(cons "--with-sysroot=/" ,flags)))))))
99 ;; For Xtensa, apply Qualcomm's patch.
100 (cross (if (string-prefix? "xtensa-" target)
101 (package-with-patch binutils
103 "ath9k-htc-firmware-binutils.patch"))
107 (define (cross-gcc-arguments target xgcc libc)
108 "Return build system arguments for a cross-gcc for TARGET, using XGCC as the
109 base compiler and using LIBC (which may be either a libc package or #f.)"
110 ;; Set the current target system so that 'glibc-dynamic-linker' returns the
112 (parameterize ((%current-target-system target))
113 ;; Disable stripping as this can break binaries, with object files of
114 ;; libgcc.a showing up as having an unknown architecture. See
115 ;; <http://lists.fedoraproject.org/pipermail/arm/2010-August/000663.html>
117 (let ((args `(#:strip-binaries? #f
118 ,@(package-arguments xgcc))))
119 (substitute-keyword-arguments args
120 ((#:configure-flags flags)
121 `(append (list ,(string-append "--target=" target)
123 `( ;; Disable libcilkrts because it is not
124 ;; ported to GNU/Hurd.
125 "--disable-libcilkrts")
126 `( ;; Disable features not needed at this stage.
127 "--disable-shared" "--enable-static"
128 "--enable-languages=c,c++"
130 ;; libstdc++ cannot be built at this stage
131 ;; ("Link tests are not allowed after
132 ;; GCC_NO_EXECUTABLES.").
133 "--disable-libstdc++-v3"
135 "--disable-threads" ;libgcc, would need libc
136 "--disable-libatomic"
137 "--disable-libmudflap"
140 "--disable-libquadmath"
141 "--disable-decimal-float" ;would need libc
142 "--disable-libcilkrts"
144 ;; When target is any OS other than 'none' these
145 ;; libraries will fail if there is no libc
147 ;; <https://lists.gnu.org/archive/html/guix-devel/2016-02/msg01311.html>
150 "--disable-libsanitizer"
153 ;; For a newlib (non-glibc) target
154 ,@(if (cross-newlib? target)
160 `(remove (cut string-match "--enable-languages.*" <>)
162 ((#:make-flags flags)
164 `(let ((libc (assoc-ref %build-inputs "libc")))
165 ;; FLAGS_FOR_TARGET are needed for the target libraries to receive
166 ;; the -Bxxx for the startfiles.
167 (cons (string-append "FLAGS_FOR_TARGET=-B" libc "/lib")
171 `(cross-gcc-build-phases ,target ,phases))))))
173 (define (cross-gcc-patches target)
174 "Return GCC patches needed for TARGET."
175 (cond ((string-prefix? "xtensa-" target)
176 ;; Patch by Qualcomm needed to build the ath9k-htc firmware.
177 (search-patches "ath9k-htc-firmware-gcc.patch"))
178 ((target-mingw? target)
179 (search-patches "gcc-4.9.3-mingw-gthr-default.patch"))
182 (define (cross-gcc-snippet target)
183 "Return GCC snippet needed for TARGET."
184 (cond ((target-mingw? target)
186 (copy-recursively "libstdc++-v3/config/os/mingw32-w64"
187 "libstdc++-v3/config/os/newlib")
191 (define* (cross-gcc target
194 (xbinutils (cross-binutils target))
196 "Return a cross-compiler for TARGET, where TARGET is a GNU triplet. Use
197 XGCC as the base compiler. Use XBINUTILS as the associated cross-Binutils.
198 If LIBC is false, then build a GCC that does not target a libc; otherwise,
200 (package (inherit xgcc)
201 (name (string-append "gcc-cross-"
202 (if libc "" "sans-libc-")
204 (source (origin (inherit (package-source xgcc))
207 (origin-patches (package-source xgcc))
208 (cons (if (version>=? (package-version xgcc) "6.0")
209 (search-patch "gcc-6-cross-environment-variables.patch")
210 (search-patch "gcc-cross-environment-variables.patch"))
211 (cross-gcc-patches target))))
212 (modules '((guix build utils)))
214 (cross-gcc-snippet target))))
216 ;; For simplicity, use a single output. Otherwise libgcc_s & co. are not
217 ;; found by default, etc.
221 `(#:implicit-inputs? #f
222 #:imported-modules ((gnu build cross-toolchain)
223 ,@%gnu-build-system-modules)
224 #:modules ((guix build gnu-build-system)
226 (gnu build cross-toolchain)
231 ,@(cross-gcc-arguments target xgcc libc)))
234 `(("ld-wrapper-cross" ,(make-ld-wrapper
235 (string-append "ld-wrapper-" target)
236 #:target (const target)
237 #:binutils xbinutils))
238 ("binutils-cross" ,xbinutils)
240 ;; Call it differently so that the builder can check whether the "libc"
242 ("libc-native" ,@(assoc-ref (%final-inputs) "libc"))
245 ,@(let ((inputs (append (package-inputs xgcc)
246 (alist-delete "libc" (%final-inputs)))))
248 ((target-mingw? target)
250 `(("libc" ,mingw-w64)
252 `(("mingw-source" ,(package-source mingw-w64))
256 ("libc:static" ,libc "static")
257 ("xkernel-headers" ;the target headers
258 ,@(assoc-ref (package-propagated-inputs libc)
265 ;; Only search target inputs, not host inputs.
266 (search-paths (cons (search-path-specification
267 (variable "CROSS_LIBRARY_PATH")
268 (files '("lib" "lib64")))
269 (map (lambda (variable)
270 (search-path-specification
272 (files '("include"))))
273 %gcc-cross-include-paths)))
274 (native-search-paths '())))
276 (define* (cross-kernel-headers target
278 (xgcc (cross-gcc target))
279 (xbinutils (cross-binutils target)))
280 "Return headers depending on TARGET."
282 (define xlinux-headers
283 (package (inherit linux-libre-headers)
284 (name (string-append (package-name linux-libre-headers)
287 (substitute-keyword-arguments
288 `(#:implicit-cross-inputs? #f
289 ,@(package-arguments linux-libre-headers))
294 (setenv "ARCH" ,(system->linux-architecture target))
295 (format #t "`ARCH' set to `~a' (cross compiling)~%" (getenv "ARCH"))
297 (invoke "make" ,(system->defconfig target))
298 (invoke "make" "mrproper" "headers_check"))
300 (native-inputs `(("cross-gcc" ,xgcc)
301 ("cross-binutils" ,xbinutils)
302 ,@(package-native-inputs linux-libre-headers)))))
304 (define xgnumach-headers
305 (package (inherit gnumach-headers)
306 (name (string-append (package-name gnumach-headers)
309 (native-inputs `(("cross-gcc" ,xgcc)
310 ("cross-binutils" ,xbinutils)
311 ,@(package-native-inputs gnumach-headers)))))
314 (package (inherit mig)
315 (name (string-append "mig-cross"))
317 `(#:modules ((guix build gnu-build-system)
320 #:phases (modify-phases %standard-phases
321 (add-before 'configure 'set-cross-headers-path
322 (lambda* (#:key inputs #:allow-other-keys)
323 (let* ((mach (assoc-ref inputs "cross-gnumach-headers"))
324 (cpath (string-append mach "/include")))
325 (for-each (cut setenv <> cpath)
326 ',%gcc-cross-include-paths)
328 #:configure-flags (list ,(string-append "--target=" target))
329 ,@(package-arguments mig)))
331 (propagated-inputs `(("cross-gnumach-headers" ,xgnumach-headers)))
332 (native-inputs `(("cross-gcc" ,xgcc)
333 ("cross-binutils" ,xbinutils)
334 ,@(package-native-inputs mig)))))
336 (define xhurd-headers
337 (package (inherit hurd-headers)
338 (name (string-append (package-name hurd-headers)
341 (native-inputs `(("cross-gcc" ,xgcc)
342 ("cross-binutils" ,xbinutils)
344 ,@(alist-delete "mig"(package-native-inputs hurd-headers))))))
346 (define xglibc/hurd-headers
347 (package (inherit glibc/hurd-headers)
348 (name (string-append (package-name glibc/hurd-headers)
352 (substitute-keyword-arguments
353 `(#:modules ((guix build gnu-build-system)
356 ,@(package-arguments glibc/hurd-headers))
358 `(modify-phases ,phases
359 (add-before 'pre-configure 'set-cross-headers-path
360 (lambda* (#:key inputs #:allow-other-keys)
361 (let* ((mach (assoc-ref inputs "gnumach-headers"))
362 (hurd (assoc-ref inputs "hurd-headers"))
363 (cpath (string-append mach "/include:"
365 (for-each (cut setenv <> cpath)
366 ',%gcc-cross-include-paths)
369 (propagated-inputs `(("gnumach-headers" ,xgnumach-headers)
370 ("hurd-headers" ,xhurd-headers)))
372 (native-inputs `(("cross-gcc" ,xgcc)
373 ("cross-binutils" ,xbinutils)
375 ,@(alist-delete "mig"(package-native-inputs glibc/hurd-headers))))))
377 (define xhurd-minimal
378 (package (inherit hurd-minimal)
379 (name (string-append (package-name hurd-minimal)
382 (substitute-keyword-arguments
383 `(#:modules ((guix build gnu-build-system)
386 ,@(package-arguments hurd-minimal))
388 `(modify-phases ,phases
389 (add-before 'configure 'set-cross-headers-path
390 (lambda* (#:key inputs #:allow-other-keys)
391 (let* ((glibc-headers (assoc-ref inputs "cross-glibc-hurd-headers"))
392 (cpath (string-append glibc-headers "/include")))
393 (for-each (cut setenv <> cpath)
394 ',%gcc-cross-include-paths)
397 (inputs `(("cross-glibc-hurd-headers" ,xglibc/hurd-headers)))
399 (native-inputs `(("cross-gcc" ,xgcc)
400 ("cross-binutils" ,xbinutils)
402 ,@(alist-delete "mig"(package-native-inputs hurd-minimal))))))
404 (define xhurd-core-headers
405 (package (inherit hurd-core-headers)
406 (name (string-append (package-name hurd-core-headers)
409 (inputs `(("gnumach-headers" ,xgnumach-headers)
410 ("hurd-headers" ,xhurd-headers)
411 ("hurd-minimal" ,xhurd-minimal)))
413 (native-inputs `(("cross-gcc" ,xgcc)
414 ("cross-binutils" ,xbinutils)
416 ,@(package-native-inputs hurd-core-headers)))))
419 ((or "i586-pc-gnu" "i586-gnu") xhurd-core-headers)
422 (define* (cross-libc target
424 (xgcc (cross-gcc target))
425 (xbinutils (cross-binutils target))
426 (xheaders (cross-kernel-headers target)))
427 "Return a libc cross-built for TARGET, a GNU triplet. Use XGCC and
428 XBINUTILS and the cross tool chain."
429 (define (cross-libc-for-target target)
430 "Return libc depending on TARGET."
432 ((or "i586-pc-gnu" "i586-gnu") glibc/hurd)
435 ;; Use (cross-libc-for-target ...) to determine the correct libc to use.
437 (if (cross-newlib? target)
439 (let ((libc (cross-libc-for-target target)))
440 (package (inherit libc)
441 (name (string-append "glibc-cross-" target))
443 (substitute-keyword-arguments
444 `(;; Disable stripping (see above.)
447 ;; This package is used as a target input, but it should not have
448 ;; the usual cross-compilation inputs since that would include
450 #:implicit-cross-inputs? #f
453 #:modules ((guix build gnu-build-system)
457 ,@(package-arguments libc))
458 ((#:configure-flags flags)
459 `(cons ,(string-append "--host=" target)
462 `(modify-phases ,phases
463 (add-before 'configure 'set-cross-kernel-headers-path
464 (lambda* (#:key inputs #:allow-other-keys)
465 (let* ((kernel (assoc-ref inputs "kernel-headers"))
466 (cpath (string-append kernel "/include")))
467 (for-each (cut setenv <> cpath)
468 ',%gcc-cross-include-paths)
469 (setenv "CROSS_LIBRARY_PATH"
470 (string-append kernel "/lib")) ; for Hurd's libihash
473 ;; Shadow the native "kernel-headers" because glibc's recipe expects the
474 ;; "kernel-headers" input to point to the right thing.
475 (propagated-inputs `(("kernel-headers" ,xheaders)))
477 ;; FIXME: 'static-bash' should really be an input, not a native input, but
478 ;; to do that will require building an intermediate cross libc.
481 (native-inputs `(("cross-gcc" ,xgcc)
482 ("cross-binutils" ,xbinutils)
483 ,@(if (hurd-triplet? target)
485 ,@(assoc-ref (package-native-inputs xheaders)
488 ,@(package-inputs libc) ;FIXME: static-bash
489 ,@(package-native-inputs libc)))))))
491 (define (native-libc target)
492 (if (target-mingw? target)
496 (define (cross-newlib? target)
497 (not (eq? (native-libc target) glibc)))
500 ;;; Concrete cross tool chains are instantiated like this:
502 ;; (define-public xgcc-armhf
503 ;; (let ((triplet "arm-linux-gnueabihf"))
504 ;; (cross-gcc triplet
505 ;; #:xbinutils (cross-binutils triplet)
506 ;; #:libc (cross-libc triplet))))
508 ;;; We don't do that here because we'd be referring to bindings from (gnu
509 ;;; packages gcc) from the top level, which doesn't play well with circular
510 ;;; dependencies among modules.