;;; GNU Guix --- Functional package management for GNU ;;; ;;; Copyright © 2023 Stefan ;;; ;;; This file is not part of GNU Guix. ;;; ;;; GNU Guix is free software; you can redistribute it and/or modify it ;;; under the terms of the GNU General Public License as published by ;;; the Free Software Foundation; either version 3 of the License, or (at ;;; your option) any later version. ;;; ;;; GNU Guix is distributed in the hope that it will be useful, but ;;; WITHOUT ANY WARRANTY; without even the implied warranty of ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ;;; GNU General Public License for more details. ;;; ;;; You should have received a copy of the GNU General Public License ;;; along with GNU Guix. If not, see . (define-module (embedded) #:use-module (guix build-system) #:use-module (guix build-system gnu) #:use-module (guix build-system trivial) #:use-module (guix build gnu-build-system) #:use-module ((guix build utils) #:select (alist-replace modify-phases)) #:use-module (guix download) #:use-module (guix gexp) #:use-module ((guix licenses) #:prefix license:) #:use-module (guix packages) #:use-module (guix utils) #:use-module (gnu packages) #:use-module (gnu packages autotools) #:use-module (gnu packages base) #:use-module ((gnu packages bootstrap) #:select (glibc-dynamic-linker)) #:use-module (gnu packages commencement) #:use-module (gnu packages compression) #:use-module (gnu packages cross-base) #:use-module (gnu packages flex) #:use-module (gnu packages gcc) #:use-module (gnu packages gdb) #:use-module (gnu packages multiprecision) #:use-module (gnu packages pkg-config) #:use-module (gnu packages texinfo) #:use-module (ice-9 optargs) #:use-module (srfi srfi-1)) (define-public (gcc-phase-fix-environment) "Give a build-phase for the GCC compilation to fix environment variables." #~(lambda* (#:key inputs #:allow-other-keys) (use-modules (srfi srfi-1)) (setenv "LD_LIBRARY_PATH" ;; The built gcc will have a workaround to ensure that glibc will always ;; find libgcc_s.so. Unfortunately during the configuration of libatomic ;; and other libraries, the libgcc_s.so is not yet available in its final ;; installation directory and this workaround causes trouble to the ;; configure script during "checking whether we are cross compiling". As ;; a mitigation we set LD_LIBRARY_PATH to the location of the not yet ;; installed libgcc_s.so. This would not be necessary, if glibc had a ;; reference to the gcc used to build it. (string-append (getcwd) "/build/gcc")) (format #t "environment variable `LD_LIBRARY_PATH' set to `~a'~%" (getenv "LD_LIBRARY_PATH")) (when (getenv "CPLUS_INCLUDE_PATH") (let* ((libc (assoc-ref inputs "libc")) (gcc (assoc-ref inputs "gcc")) ; This is different to #$gcc! (paths-to-delete (map (lambda (package) (string-append package "/include")) (filter-map identity (list libc gcc))))) (setenv "CPLUS_INCLUDE_PATH" ;; The gcc package used by the gnu-build-system to build this gcc ;; puts the include paths to the C++ headers and to the libc headers ;; into CPLUS_INCLUDE_PATH. This causes trouble in the gcc build ;; process when -nostdinc++ is used. As a mitigation we remove them. ;; This would not be necessary, when using this built gcc instead. (string-join (remove (lambda (path) (member path paths-to-delete)) (string-split (getenv "CPLUS_INCLUDE_PATH") #\:)) ":")) (format #t "environment variable `CPLUS_INCLUDE_PATH' set to `~a'~%" (getenv "CPLUS_INCLUDE_PATH")))))) (define*-public (gcc-phase-pre-configure #:key (libc glibc) (dynamic-linker (glibc-dynamic-linker)) (startfile-dir "/lib/")) "Give a build-phase for the GCC compilation to modify the source-code. Use the LIBC package for embedded search-paths. The path DYNAMIC-LINKER is appended to LIBC to form the absolute path to the dynamic-linker. The STRTFILE-DIR is a suffix for LIBC to form the path to startfiles like crt0.o from newlib. All default values match for glibc. For newlib omit DYNAMIC-LINKER and set STARTFILE-DIR to (string-append \"/\" target \"/lib/\")." #~(lambda _ (substitute* "Makefile.in" ;; Don't store configure arguments, to avoid retaining references to ;; build-time dependencies like "--with-…=/gnu/store/…". (("@TOPLEVEL_CONFIGURE_ARGUMENTS@") "")) (substitute* (find-files "gcc/config") ;; Enforce any /lib64 directory to just be /lib. (("/lib64") "/lib")) (when #$dynamic-linker (substitute* (find-files "gcc/config" "^.+\\.h$" #:directories? #t) ;; Enforce anything looking like some /lib/ld.so.2 to be the linker. (("[^ :;\"{]+/ld.*[_.]so(\\.[0-9]+)?") (string-append #$libc #$dynamic-linker)))) (substitute* "gcc/configure" ;; Prevent auto-host.h in output:lib to create a cyclic dependency ;; referencing output:out. (("PREFIX_INCLUDE_DIR \"\\$prefix/include\"") "PREFIX_INCLUDE_DIR \"$libdir/include\"")) (substitute* "gcc/genmultilib" ;; Enforce proper invokations of sh. (("#!/bin/sh") (string-append "#!" (which "sh")))) (substitute* "gcc/gcc.cc" ;; The STARTFILE_PREFIX_SPEC defines where to find crt1.o and other ;; start files of libc. Replace it with a proper path to the libc. ;; Note: This path is relative to the sysroot which therefore must be /. (("startfile_prefix_spec = STARTFILE_PREFIX_SPEC;") (string-append "startfile_prefix_spec = \"" #$libc #$startfile-dir "\";"))) (substitute* "libstdc++-v3/python/Makefile.in" ;; Change pythondir from #$output:out to #$output:lib to prevent ;; #$output:lib/lib/libstdc++.so.*-gdb.py to create a cyclic dependency ;; to #$output:out/share/…/python. This moves all python files to ;; #$output:lib. The option --with-python-dir is still usable. (("pythondir = \\$\\(datadir\\)") "pythondir = $(libdir)/share") (("pythondir = \\$\\(prefix\\)") "pythondir = $(libdir)")) #!(substitute* "libsanitizer/asan/asan_linux.cpp" ;; Ensure PATH_MAX is defined by including the proper header file. ;; https://gcc.gnu.org/bugzilla//show_bug.cgi?id=99476 ;; https://gcc.gnu.org/bugzilla//show_bug.cgi?id=106998 ;; The gcc package used by the gnu-build-system is to blame here. This ;; patch is unnecessary when not using --disable-bootstrap. (("#include ") #$(string-join (list "#include " "#if SANITIZER_LINUX" "#include " "#endif") "\n")))!#)) (define*-public (gcc-configure-flags #:key (libc glibc) (kernel-headers (car (assoc-ref (package-propagated-inputs glibc) "kernel-headers")))) "Give the configure-flags for the GCC compilation referring to the LIBC and KERNEL-HEADERS packages. The defaults refer to glibc and the kernel-headers used to build glibc." #~(list ;; The first set of include paths consinsts of #$gcc/include-c++/… and ;; #$gcc:lib/…/include. Second is usually /usr/local, which we replace ;; with the empty #$output:lib/include path. (string-append "--with-local-prefix=" #$output:lib) ;; Third is #$gcc:lib/…/include-fixed, which expects #$libc/include and ;; #$kernel-headers/include to follow in this order. ;; Fourth and usually the last include path is /usr/include containing all ;; system headers. It is only possible to specify one path for this. Set ;; the #$libc/include path and prevent the use of /usr/include. (string-append "--with-native-system-header-dir=" #$libc "/include") ;; The final include path has to be #$kernel-headers/include, which has to ;; be after #$libc/include. There is only -idirafter left to achieve ;; this. Add #$output:lib/lib as a built-in link-time search path. ;; Add #$libc/lib and #$libc/static as built-in link-time search paths. ;; Add a runtime search path to #$libc/lib, if not linked statically. ;; This search path to #$libc/lib may not be technically necessary because ;; of the dynamic linker in there, but better use a complete list. ;; Actually libc needs a DT_RUNPATH entry to the libgcc_s.so of the GCC ;; used to build it. This is missing and may requires a fix. As a ;; workaround one can force any program built by this GCC and not linked ;; statically to load libgcc_s.so by embedding the -lgcc_s option and ;; adding a runtime search path to libgcc_s.so as well. (string-append "--with-specs=" ;; Embed the path to the kernel-headers. "-idirafter " #$kernel-headers "/include " ;; Embed the link-time search path to libgcc_s.so, libstdc++.so, etc. "%x{-L" #$output:lib "/lib} " ;; Embed the link-time search paths to #$libc/lib and #$libc:static/lib. "%x{-L" #$libc "/lib} %x{-L" #$libc:static "/lib} " ;; Embed the runtime search path to #$libc/lib, if not staticlally ;; linked. "%{nolibc|nostdlib|static:; :%x{-rpath=" #$libc "/lib}} " ;; This is a workaround to ensure a pre-loaded libgcc_s.so for libc if ;; not statically linking. The libstdc++.so and other shared libraries ;; are statically linked but use the option -lgcc_s. Unfortunately it ;; seems to be impossible to check for the presence of -lgcc_s. Adding ;; the -rpath option conditionally, if not linking statically, has the ;; risk to not add it although needed. Adding it unconditionally may add ;; it needlessly, which prevents building the dynamic linker of libc, ;; but makes the make-flags #~(list "LDFLAGS=-Wl,-rpath=$(libdir)/lib") ;; obsolete. As a GCC referencing the dynamic linker cannot be used to ;; build it, the -rpath is added unconditionally here. "%{nodefaultlibs|nostdlib|static|static-libgcc|static-pie:; " ":%x{-lgcc_s}} %x{-rpath=" #$output:lib "/lib}") ;; Prevent the C++ headers in #$output:lib, put them in #$output:out ;; instead. Use an unconventional path to prevent it from being added to ;; the environment variables C_INCLUDE_PATH and CPLUS_INCLUDE_PATH. "--with-gxx-include-dir=$(prefix)/include-c++" ;; As libc is limited, gcc will not be usable for 32 and 64 bit builds. "--disable-multilib" ;; Disable all language frontends except for C and C++. "--enable-languages=c,c++" ;; Save space by disabling pre-compiled libstdc++ headers. "--disable-libstdcxx-pch" ;; Use the zlib package instead of the zlib bundled with gcc. "--with-system-zlib" ;; Avoid parallel linking to not crash on systems with limited memory. "--enable-link-serialization" ;; Prevent the built gcc to build itself again to save time. #!"--disable-bootstrap"!#)) (define-public (make-gcc12 phase-pre-configure configure-flags) "Make a GCC package using the PHASE-PRE-CONFIGURE and the CONFIGURE-FLAGS in the build-process." (package (name "gcc12") (version "12.2.0") (source (origin (method url-fetch) (uri (string-append "mirror://gnu/gcc/gcc-" version "/gcc-" version ".tar.xz")) (sha256 (base32 "1zrhca90c7hqnjz3jgr1vl675q3h5lrd92b5ggi00jjryffcyjg5")) (patches (search-patches "gcc-12-strmov-store-file-names.patch")))) (build-system gnu-build-system) (outputs '("out" "lib" "debug")) (inputs (list gmp mpfr mpc isl zstd zlib)) (arguments (list #:tests? #f #:out-of-source? #t #:configure-flags configure-flags #:phases #~(modify-phases %standard-phases (add-after 'set-paths 'fix-environment #$(gcc-phase-fix-environment)) (add-before 'configure 'pre-configure #$phase-pre-configure)))) (native-search-paths (list (search-path-specification (variable "CPLUS_INCLUDE_PATH") (files (list "include"))) (search-path-specification (variable "C_INCLUDE_PATH") (files (list "include"))) (search-path-specification (variable "LIBRARY_PATH") (files (list "lib"))))) (synopsis "GNU Compiler Collection") (description "GCC is the GNU Compiler Collection. It provides compiler front-ends for several languages, including C, C++, Objective-C, Fortran, Java, Ada, and Go. It also includes runtime support libraries for these languages.") (home-page "https://gcc.gnu.org/") (license license:gpl3+))) (define-public gcc12 (make-gcc12 (gcc-phase-pre-configure) (gcc-configure-flags))) (define-public guix-locpath (package (name "guix-locpath") (version "1.0") (source #f) (build-system trivial-build-system) (arguments (list #:builder #~(mkdir #$output))) (native-search-paths (list (search-path-specification (variable "GUIX_LOCPATH") (files '("lib/locale"))))) (home-page #f) (synopsis "Access for glibc to locales") (description "The guix-locpath package sets the environment variable GUIX_LOCPATH to make all locale related functions of glibc usable without propagating glibc itself. This is usefull to prevent glibc include paths to be exposed via C_INCLUDE_PATH and similar environment variables, to keep a defined include order with embedded paths in GCC to glibc.") (license (package-license glibc-utf8-locales)))) (define*-public (make-c-toolchain gcc binutils #:optional ld-wrapper) "Make a C-toolchain consisting of GCC, BINUTILS, guix-locpath and optionally LD-WRAPPER packages. The result can be used by the transformation function 'package-with-c-toolchain' and to build a GCC-toolchain package with 'make-gcc-toolchain-package'. The guix-locpath package is used instead of the glibc package to prevent glibc and the kernel-headers from appearing in the C_INCLUDE_PATH, CPLUS_INCLUDE_PATH, and similar environment variables. The GCC package is expected to have the necessary paths build-in to preserve a necessary include-order." (let ((build-inputs (list (list "guix-locpath" guix-locpath) (list "gcc" gcc) (list "binutils" binutils)))) (if ld-wrapper ;; The ld-wrapper has to be in front of binutils. (cons (list "ld-wrapper" ld-wrapper) build-inputs) build-inputs))) (define*-public (make-gcc-toolchain-package c-toolchain) "Make a GCC-toolchain package from C-TOOLCHAIN. The C-TOOLCHAIN argument must be a list of inputs (label/package tuples) providing equivalent functionality as the 'gcc-toolchain' package as passed to 'package-with-c-toolchain'." (let ((gcc (car (assoc-ref c-toolchain "gcc")))) (package (name (string-append (package-name gcc) "-toolchain")) (version (package-version gcc)) (source #f) (build-system trivial-build-system) (arguments (list #:modules '((guix build union)) #:builder #~(begin (use-modules ((guix build union))) (union-build #$output (quote #$(map second c-toolchain)))))) (synopsis "Complete GCC toolchain for C/C++ development") (description "This package provides a complete GCC toolchain for C/C++ development to be installed in user profiles. This includes GCC and Binutils. GCC is the GNU Compiler Collection.") (home-page "https://gcc.gnu.org/") (license license:gpl3+)))) (define-public gcc12-c-toolchain (make-c-toolchain gcc12 binutils ld-wrapper)) (define-public gcc12-toolchain (make-gcc-toolchain-package gcc12-c-toolchain)) (define*-public (make-newlib-4.3 target #:key (configure-flags '("--disable-newlib-supplied-syscalls" "--enable-newlib-io-long-long" "--enable-newlib-io-c99-formats" "--enable-newlib-mb" "--enable-newlib-reent-check-verify" "--enable-newlib-register-fini" "--enable-newlib-retargetable-locking" "--disable-dependency-tracking")) (cross-gcc (cross-gcc target)) (cross-binutils (cross-binutils target))) "Make a newlib package for TARGET with the given CONFIGURE-FLAGS, CROSS-GCC and CROSS-BINUTLIS packages for building." (package (name (string-append "newlib-" target)) (version "4.3.0") (source (origin (method url-fetch) (uri "ftp://sourceware.org/pub/newlib/newlib-4.3.0.20230120.tar.gz") (sha256 (base32 "0l2iycz12m9r8czc08isykzh1mr4xs9d13n5n2wqxqsrmycjm9l3")))) (build-system gnu-build-system) (arguments (list #:out-of-source? #t ;; The configure-flags are taken from newlib_configure found in: ;; https://armkeil.blob.core.windows.net/developer/Files/downloads/gnu/12.2.mpacbti-bet1/manifest/arm-gnu-toolchain-arm-none-eabi-abe-manifest.txt ;; Got that link in section "Linaro ABE example manifest files for ;; Linux hosted cross toolchains" form: ;; https://developer.arm.com/downloads/-/arm-gnu-toolchain-downloads #:configure-flags #~(quote #$(cons (string-append "--target=" target) configure-flags)) #:phases #~(modify-phases %standard-phases ;; TODO: Remove nano related files after installation. (add-after 'unpack 'fix-references-to-/bin/sh (lambda _ (substitute* (find-files "libgloss" "^Makefile\\.in$") ;; There are plenty Makefile.in below libgloss which ;; reference /bin/sh. These must be fixed. (("/bin/sh") (which "sh")))))))) (native-inputs (list cross-gcc cross-binutils texinfo)) (home-page "https://www.sourceware.org/newlib/") (synopsis "C library for use on embedded systems") (description "Newlib is a C library intended for use on embedded systems. It is a conglomeration of several library parts that are easily usable on embedded products.") (license (license:non-copyleft "https://www.sourceware.org/newlib/COPYING.NEWLIB")))) (define*-public (make-newlib-nano-4.3 target #:key (cross-gcc (cross-gcc target)) (cross-binutils (cross-binutils target))) "Make a newlib-nano package for TARGET with the given CROSS-GCC and CROSS-BINUTLIS packages for building." (package (inherit (make-newlib-4.3 target #:configure-flags '("--disable-newlib-fseek-optimization" "--disable-newlib-fvwrite-in-streamio" "--disable-newlib-supplied-syscalls" "--disable-newlib-unbuf-stream-opt" "--disable-newlib-wide-orient" "--enable-lite-exit" "--enable-newlib-global-atexit" "--enable-newlib-nano-formatted-io" "--enable-newlib-nano-malloc" "--enable-newlib-reent-check-verify" "--enable-newlib-reent-small" "--enable-newlib-retargetable-locking" "--disable-dependency-tracking") #:cross-gcc cross-gcc #:cross-binutils cross-binutils)) (name (string-append "newlib-nano-" target)) ;; TODO: Add nano suffix to installed files, keep nano related files. (synopsis "C library for use on embedded systems with limited memory"))) (define-public newlib-arm-none-eabi-4.3 (make-newlib-4.3 "arm-none-eabi")) (define-public newlib-nano-arm-none-eabi-4.3 (make-newlib-nano-4.3 "arm-none-eabi")) (define-public (gcc-cross-newlib-arm-configure-flags target libc) "Modify configure-flags to build a GCC cross-compiler for the Arm target TARGET using newlib as LIBC." #~(list (string-append "--target=" #$target) ;; All paths to --with-… options are relative to the sysroot. As store ;; pathes are absolute, the sysroot needs to be set to /. "--with-sysroot=/" ;; The first set of include paths consinsts of #$gcc/include-c++/… and ;; #$gcc:lib/…/include. Second is usually /usr/local, which we replace ;; with the empty #$output:lib/include path. (string-append "--with-local-prefix=" #$output:lib) ;; Third is #$gcc:lib/…/include-fixed, which expects #$libc/include and ;; #$kernel-headers/include to follow in this order. ;; Fourth and usually the last include path is /usr/include containing all ;; system headers. It is only possible to specify one path for this. Set ;; the #$libc/include path and prevent the use of /usr/include. ;; Using newlib as libc for bare-metal does not require kernel-headers. (string-append "--with-native-system-header-dir=" #$libc "/" #$target "/include") ;; Add #$output/#$target/lib and #$libc/#$target/lib as a built-in ;; link-time search path. (string-append "--with-specs=" ;; Embed the link-time search path to libgcc, libstdc++, etc. "%x{-L" #$output "/" #$target "/lib} " ;; Embed the link-time search paths to libc. "%x{-L" #$libc "/" #$target "/lib}") ;; Prevent the C++ headers in #$output:lib, put them in #$output:out ;; instead. Use an unconventional path to prevent it from being added to ;; the environment variables C_INCLUDE_PATH and CPLUS_INCLUDE_PATH. "--with-gxx-include-dir=$(prefix)/include-c++" ;; Ensure GCC is build for newlib. "--with-newlib" ;; As newlib has multiple target libraries, enable their support. "--enable-multilib" "--with-multilib-list=aprofile,rmprofile" ;; As newlib does not have a dynamik-linker, disable shared builds. "--disable-shared" ;; Disable all language frontends except for C and C++. "--enable-languages=c,c++" ;; Save space by disabling pre-compiled libstdc++ headers. "--disable-libstdcxx-pch" ;; Use the zlib package instead of the zlib bundled with gcc. "--with-system-zlib" ;; Avoid parallel linking to not crash on systems with limited memory. "--enable-link-serialization")) (define*-public (make-cross-gcc gcc cross-libc cross-binutils) "Make a GCC cross-compiler package based on a still native but modified GCC package using the CROSS-LIBC and CROSS-BINUTILS packages." (package (inherit gcc) (name (string-append (package-name gcc) "-cross-" (package-name cross-libc))) (inputs '()) (native-inputs (append (list (list "cross-binutils" cross-binutils)) (package-inputs gcc))))) (define*-public (make-cross-c-toolchain target cross-gcc cross-binutils #:optional cross-ld-wrapper) "Make a cross-C-toolchain targeting TARGET of the CROSS-GCC, CROSS-BINUTILS, guix-locpath and optionally CROSS-LD-WRAPPER packages. The result can be used by the transformation function 'package-with-c-toolchain' and to build a GCC-toolchain package with 'make-gcc-toolchain-package'. The guix-locpath package is used instead of the glibc package to prevent glibc and the kernel-headers from appearing in the C_INCLUDE_PATH, CPLUS_INCLUDE_PATH, and similar environment variables. The GCC package is expected to have the necessary paths build-in to preserve a necessary include-order." (append (make-c-toolchain cross-gcc cross-binutils cross-ld-wrapper) ;; GCC looks for as and other tools from cross-binutils in PATH. ;; However, the cross-binutils package contains only executables ;; pefixed with the target name in its bin directory. The ones ;; not prefixed reside in its target/bin directory. We create a ;; new package, which links that #$target/bin directory as bin. ;; Note: The linker is invoked by collect2, which has different lookup ;; rules as GCC and finds a prefixed target-ld. (list (list "binutils-for-toolchain" (package (inherit cross-binutils) (name (string-append (package-name cross-binutils) "-for-toolchain")) (version (package-version cross-binutils)) (source #f) (build-system trivial-build-system) (arguments (list #:builder #~(begin (mkdir #$output) (symlink #$(file-append cross-binutils "/" target "/bin") (string-append #$output "/bin")))))))))) (define*-public (make-cross-arm-none-eabi-c-toolchain gcc make-gcc make-cross-newlib) "Make a C-toolchain targeting arm-none-eabi consisting of a cross-compiler, cross-compiled Binutils, and a newlib C-library. The cross-compiler will be build with another toolchain using the given host GCC and Binutils. The function MAKE-GCC is used to create a GCC cross-compiler package using the newlib C-library package created with MAKE-CROSS-NEWLIB. The result can be used by the transformation function 'package-with-c-toolchain' and to build a GCC-toolchain package with 'make-gcc-toolchain-package'." (let* ((target "arm-none-eabi") (c-toolchain (make-c-toolchain gcc binutils ld-wrapper)) (cross-binutils (cross-binutils target)) (cross-newlib (make-cross-newlib target)) (cross-gcc (package-with-c-toolchain (make-cross-gcc (make-gcc (gcc-phase-pre-configure #:libc cross-newlib #:startfile-dir (string-append "/" target "/lib/")) (gcc-cross-newlib-arm-configure-flags target cross-newlib)) cross-newlib cross-binutils) c-toolchain))) (make-cross-c-toolchain target cross-gcc cross-binutils))) (define-public gcc12-cross-newlib-arm-none-eabi-c-toolchain (make-cross-arm-none-eabi-c-toolchain gcc12 make-gcc12 make-newlib-4.3)) (define-public gcc12-cross-newlib-nano-arm-none-eabi-c-toolchain (make-cross-arm-none-eabi-c-toolchain gcc12 make-gcc12 make-newlib-nano-4.3)) (define-public gcc12-cross-newlib-arm-none-eabi-toolchain (package (inherit (make-gcc-toolchain-package gcc12-cross-newlib-arm-none-eabi-c-toolchain)) (synopsis "Complete GCC toolchain for C/C++ cross development on ARM Cortex-A and Cortex-M micro-controllers with newlib") (description "This package provides a complete GCC toolchain for C/C++ cross development on ARM Cortex-A and Cortex-M micro-controllers to be installed in user profiles. This includes GCC, newlib and Binutils. GCC is the GNU Compiler Collection."))) (define-public gcc12-cross-newlib-nano-arm-none-eabi-toolchain (package (inherit (make-gcc-toolchain-package gcc12-cross-newlib-nano-arm-none-eabi-c-toolchain)) (synopsis "Complete GCC toolchain for C/C++ cross development on ARM Cortex-A and Cortex-M micro-controllers with newlib-nano") (description "This package provides a complete GCC toolchain for C/C++ cross development on ARM Cortex-A and Cortex-M micro-controllers to be installed in user profiles. This includes GCC, newlib-nano and Binutils. GCC is the GNU Compiler Collection."))) (define-public gcc12-cross-newlib-arm-none-eabi (car (assoc-ref gcc12-cross-newlib-arm-none-eabi-c-toolchain "gcc"))) (define-public gcc12-cross-newlib-nano-arm-none-eabi (car (assoc-ref gcc12-cross-newlib-nano-arm-none-eabi-c-toolchain "gcc"))) (define-public binutils-cross-arm-none-eabi (car (assoc-ref gcc12-cross-newlib-nano-arm-none-eabi-c-toolchain "binutils")))