[2024-feb-29] Sad news: Eric Layton aka Nocturnal Slacker aka vtel57 passed away on Feb 26th, shortly after hospitalization. He was one of our Wiki's most prominent admins. He will be missed.

Welcome to the Slackware Documentation Project

¡Esta es una revisión vieja del documento!


En proceso de traducción. rramp

Slackware ARM GCC aarch64-linux compilación cruzada para la Raspberry Pi

Prefacio

Estaba pensando en la CPU de 64 bits Cortex-A53 de mi Raspberry Pi 3 y por qué estoy usando principalmente el sistema operativo Slackware ARM de 32 bits en ella. Entonces empecé a preguntarme si sería posible construir un kernel arm64 y módulos para correr con Slackware ARM. Después de leer acerca de cómo se podría lograr esto, parecía claro que se requeriría cierta compilación cruzada. Aunque tengo algo de experiencia en la construcción de núcleos (kernel) Linux, especialmente para la plataforma Raspberry Pi, nunca había hecho ninguna compilación cruzada hasta hace una semana (2016-12-15). Así que, todo este concepto era totalmente nuevo para mí.

Para mi primer intento (y en gran parte basado en la lectura de cómo lo hacían otros usuarios) usé un sistema Ubuntu 16.04.1 LTS (64 bits) para compilar un núcleo arm64 para el Raspberry Pi 3. Sin embargo, los resultados de hacer las cosas por este método fueron un tanto escasos y crearon muchos errores imprevistos. Entonces recordé algo Mozes había publicado el his Slackware ARM FAQ page sobre paquetes que se estaban construyendo de forma nativa. Una investigación más profunda me llevó a darme cuenta de que el éxito asegurado probablemente se encontraría al compilar de forma cruzada en un dispositivo ARM usando Slackware ARM. ¡Eso es exactamente lo que hice! Muy exitosamente, debo añadir. Gracias de nuevo, Mozes. <3

Como han resultado las cosas, no fue tan difícil. Se requirió invertir algún tiempo en la lectura sobre las cadenas de herramientas (toolchains) y cómo construir empleando compiladores cruzados, así como en probar los resultados de la compilación cruzada, pero en general ha sido un proceso relativamente simple. Usar Slackware ARM current para compilar la arquitectura aarch64 fue la clave del éxito aquí. Ahora soy muy consciente de que, en comparación, intentar compilar aarch64 en un sistema Ubuntu x86_64 era menos que productivo.

Notas

Slackware ARM current Slackware ARM current was used on a Raspberry Pi 3 to build and install the GCC aarch64-linux cross-compiler, and build the arm64 Linux kernel, modules, and device tree blob(s). That's not to say Slackware ARM 14.2 won't work too, but I just didn't do any cross-compiling on the soft float port. The same applies to the Raspberry Pi 1 and 2. Even though it should be possible to carry out aarch64 cross-compiler builds on these devices, I didn't do any testing with them. Also bear in mind that configuration options and settings will need to be considered first.

Requerimientos

Como requisito previo, deberías haberlo logrado;

  • Una Raspberry Pi 3 corriendo Slackware ARM con aproximadamente 8GB de espacio libre en tu sistema.
  • gawk, git, bison y flex, ya instalado en tu sistema.
  • Un lector de tarjetas microSD USB para conectar con su Raspberry Pi 3.
  • Una tarjeta microSD (de respuesto) con Slackware current instalada en ella no es esencial, pero se aconseja.

De que se trata

Este tutorial le permitirá;

  • Descargar los paquetes de fuentes requeridos con el objetivo de construir un compilador cruzado de GCC en Slackware ARM.
  • Descargar el kernel de Linux para la Raspberry Pi GitHub y cambie a la rama de desarrollo de 64 bits.
  • configure, e instale, un compilador cruzado GCC aarch64-linux (arm64) sobre tu Raspberry Pi 3.
  • Construir un kernel aarch64 (arm64), módulos, y árbol de dispositivos e instalarlos en su tarjeta microSD actual Slackware ARM (de repuesto).
  • build an aarch64 (arm64) Linux kernel, modules, and device tree blob(s), and install them on your (spare) Slackware ARM current microSD card.
  • arrancar con éxito Slackware ARM actual en su Raspberry Pi 3 ejecutando un kernel aarch64 (arm64).
Para no arriesgarse a estropear el sistema ARM de Slackware que utiliza para la compilación cruzada, se debe utilizar una tarjeta microSD (de repuesto) que contenga un sistema ARM de Slackware que funcione para instalar el núcleo Linux arm64, los módulos y el árbol de dispositivos. Necesitará una versión reciente (es decir, posterior a septiembre de 2016) del Raspberry Pi bootloader/GPU firmware instalada en esta tarjeta microSD (de repuesto) para evitar problemas. Para estar seguro, arranque su RPi3 con él y actualice el firmware. La versión del núcleo de Linux en esta tarjeta microSD (de repuesto) no importa, ya que la sustituirá por el núcleo aarch64 (arm64).

Descarga del código fuente requerido y configuración

Primero de todo, como un usuario normal (es decir, no 'root') cree un directorio de trabajo. Por ejemplo, yo usualmente trabajo en el directorio /tmp:

cd /tmp
mkdir build-dir
cd build-dir

Este es el directorio donde se va a descargar todos los paquetes requeridos y las fuentes de Linux RPi.

Descargue el código fuente del kernel de Linux

Use el siguiente comando 'git' para descargar el kernel Linux para la Raspberry Pi en un directorio llamado 'linux'.

git clone https://github.com/raspberrypi/linux linux

Esto puede tardar un poco, dependiendo de la velocidad de su conexión a Internet y otros factores. Una vez que se haya completado necesita cambiar a la rama de desarrollo del kernel de 64 bits.

cd linux
git checkout rpi-4.8.y

Cuando eso esté hecho, deberías ver un mensaje de que 'origin/rpi-4.8.y' es la rama actual.

Descarga del código fuente

Antes de descargar el código fuente del paquete necesario para construir el compilador cruzado GCC, tenga en cuenta que pueden existir versiones de paquetes más recientes que las que se muestran aquí. Es posible que desee instalar versiones más recientes. Siempre es una buena idea revisar. Para mantener las cosas simples, puede considerar descargar una versión de GCC que coincida con la que tiene instalada actualmente. He leído muchos artículos sobre esto y la mayoría aconseja instalar la última versión de GCC disponible. Sin embargo, si está ejecutando Slackware ARM current tendrá instalado gcc-5.4.0 y esto es adecuado para lo que se necesita.

Así que, primero muévete de vuelta al directorio 'build-dir' y entonces descarga los siguientes paquetes.

cd ../
wget -nc https://ftp.gnu.org/gnu/binutils/binutils-2.27  
wget -nc ftp://gcc.gnu.org/pub/gcc/infrastructure/cloog-0.18.1   
wget -nc https://ftp.gnu.org/gnu/gcc/gcc-5.4.0  
wget -nc https://ftp.gnu.org/gnu/glibc/glibc-2.24  
wget -nc https://ftp.gnu.org/gnu/gmp/gmp-6.1.1  
wget -nc ftp://gcc.gnu.org/pub/gcc/infrastructure/isl-0.16.1  
wget -nc https://ftp.gnu.org/gnu/mpc/mpfr-3.1.5  
wget -nc https://ftp.gnu.org/gnu/mpfr/mpc-1.0.3

Desempaquetado de los tarballs descargados

Ahora desempaqueta todos los tarballs descargados. Puede hacer esto fácilmente con el comando 'for'.

for t in *.tar*; do tar -xvf $t; done

Una vez que esto se haya completado, puede usar el comando 'ls' para verificar que los directorios están presentes.

Creación de enlaces simbólicos de dependencias de GCC

Ahora es necesario crear algunos enlaces simbólicos en el directorio gcc-5.4.0. Estos apuntarán a algunos de los directorios fuente que acaba de desempaquetar, que son dependencias de GCC, y cuando estos enlaces simbólicos estén presentes, GCC los construirá automáticamente.

cd gcc-5.4.0
ln -sf ../cloog-0.18.1 cloog
ln -sf ../gmp-6.1.1 gmp
ln -sf ../isl-0.16.1 isl
ln -sf ../mpfr-3.1.5 mpc
ln -sf ../mpfr-3.1.5 mpfr

Alternativamente, algunos artículos le aconsejarán que utilice el siguiente comando para lograr lo mismo.

cd gcc-5.4.0
./contrib/download_prerequisites

Personalmente, siempre prefiero el método manual porque entonces sé lo que se está descargando/instalando y qué esperar. Depende de usted el método que utilice.

Creación del directorio de instalación del compilador cruzado de GCC

Lo siguiente que hay que hacer es crear un directorio de instalación. Este es el directorio donde se instalará la cadena de herramientas. Una vez más, me gusta trabajar en /tmp para que el directorio de instalación se cree allí.

cd /tmp
mkdir gcc-cross

Exportación del directorio de instalación PATH

Es necesario exportar el directorio de instalación /bin a la variable $PATH de tu usuario.

export PATH=/tmp/gcc-cross/bin:$PATH

Para comprobar que esto ha funcionado, utilice el siguiente comando:

echo $PATH

Debería ver que la primera entrada $PATH es en la carpeta /bin de su directorio de instalación. Es importante que la carpeta /bin de su directorio de instalación aparezca antes de cualquier otra entrada en $PATH.

/tmp/gcc-cross/bin:/usr/local/bin:/usr/bin:/bin:/usr/games:/usr/lib/kde4/libexec:/usr/lib/qt/bin

Construcción del compilador cruzado aarch64 de GCC

Ahora con todo esto en su lugar, la concentración se centra en la construcción del ensamblador cruzado, el desensamblador cruzado, el cross-linker y otras herramientas útiles.

Construyendo binutils

Primero regrese al directorio 'build-dir' y luego cree un directorio de compilación para binutils. Notará las varias opciones de compilación pero como una explicación rápida; '–with-sysroot' básicamente le dice a binutils que habilite el soporte'sysroot' en el compilador cruzado apuntando a un directorio vacío por defecto, '–target=aarch64-linux' es el tipo de sistema de destino (arm64), y '–disable-multilib' significa que sólo queremos que los binutils trabajen con el conjunto de instrucciones aarch64 y nada más.

cd build-dir
mkdir build-binutils
cd build-binutils
../binutils-2.27/configure --prefix=/tmp/gcc-cross --with-sysroot --target=aarch64-linux --disable-multilib
make -j4 
make install

Instalación de las cabeceras del kernel de Linux

Aquí necesitas instalar las cabeceras del núcleo de Linux. Note la opción 'ARCH=arm64' para el proceso make. GCC usa 'aarch64' donde el kernel de Linux usa 'arm64'. Los dos proyectos de código abierto independientes identifican la misma arquitectura de CPU de forma diferente.

cd ../linux
make ARCH=arm64 INSTALL_HDR_PATH=/tmp/gcc-cross/aarch64-linux headers_install

Construir GCC

Primero muévete al directorio 'buit-dir' y cree un directorio de compilación para GCC antes de construirlo. Note que solo han sido especificados como lenguajes de construcción C y C++. Eso es todo lo que necesitarás aquí. De hecho, las opciones de lenguaje de construcción disponibles permiten sólo una, o una selección, o todas, de las siguientes opciones '–enable-languages=all,ada,c,c++,fortran,go,jit,lto,objc,obj-c++'.

cd ../
mkdir build-gcc
cd build-gcc
../gcc-5.4.0/configure --prefix=/tmp/gcc-cross --target=aarch64-linux --enable-languages=c,c++ --disable-multilib
make -j4 all-gcc
make install-gcc

Construir e instalar glibc

Primero vaya al directorio 'build-dir' y cree un directorio 'build-glibc'. Luego muévase al directorio 'build-glibc' antes de construirlo. –build=$MACHTYPE' es una variable de entorno predefinida que describe la Raspberry Pi 3 (en este caso) y es necesario compilar algunas herramientas adicionales que se utilizan durante el proceso de construcción. Observe que está instalando los archivos de inicio de la biblioteca C en el directorio de instalación (csu/crt1.o, csu/crti.o, y csu/crtn.o) por separado porque no parece haber una regla “make” que lo haga sin crear otros problemas.

cd ../
mkdir -p build-glibc
cd build-glibc
../glibc-2.24/configure --prefix=/tmp/gcc-cross/aarch64-linux --build=$MACHTYPE --host=aarch64-linux --target=aarch64-linux --with-headers=/tmp/gcc-cross/aarch64-linux/include --disable-multilib libc_cv_forced_unwind=yes    
make install-bootstrap-headers=yes install-headers
make -j4 csu/subdir_lib
install csu/crt1.o csu/crti.o csu/crtn.o /tmp/gcc-cross/aarch64-linux/lib
$ARCH_TARGET-gcc -nostdlib -nostartfiles -shared -x c /dev/null -o /tmp/gcc-cross/aarch64-linux/lib/libc.so
touch /tmp/gcc-cross/aarch64-linux/include/gnu/stubs.h

Construcción de la biblioteca de soporte glibc

Muevase al directorio 'build-gcc' una vez más contruya las librerías de soporte para el compilador cruzado.

cd ../build-gcc
make -j4 all-target-libgcc
make install-target-libgcc

Concluir la construcción de la biblioteca glibc C

Muevase al directorio 'build-glibc' para finalizar de construir la librería glibc y entonces instálalo.

cd ../build-glibc
make -j4
make install

Finalización de la construcción de la librería GCC C++

Muevase al directorio 'build-glibc' para finalizar de construir la librería GCC C++ y luego instalela.

cd ../build-gcc
make -j4
make install

Probando el compilador cruzado

Para testear/chequear que tu compilador cruzado GCC aarch64-linux está funcionando correctamente ejecute los siguientes comandos.

aarch64-linux-gcc -v

Usted debería obtener una respuesta similar a la siguiente:

Using built-in specs.
COLLECT_GCC=aarch64-linux-gcc
COLLECT_LTO_WRAPPER=/tmp/gcc-cross/libexec/gcc/aarch64-linux/5.4.0/lto-wrapper
Target: aarch64-linux
Configured with: ../gcc-5.4.0/configure --prefix=/tmp/gcc-cross --target=aarch64-linux --enable-languages=c,c++ --disable-multilib
Thread model: posix
gcc version 5.4.0 (GCC)

Una vez completado este proceso, exporte la ruta del compilador cruzado de GCC a su usuario normal. Si desea realizar una compilación cruzada, hágalo una vez que haya reiniciado el sistema para que el compilador cruzado de GCC pueda localizarse a través de $PATH de su usuario. También tiene la opción de agregar este comando a tu ~/.profile como configuración permanente. Si decide o no agregar permanentemente el PATH de GCC a su perfil ~/.profile depende totalmente de usted. Si está usando su sistema actual Slackware ARM para construir exclusivamente paquetes aarch64 (arm64), entonces tendría sentido hacerlo.

Ejemplo de comandos para exportar:

export PATH=/tmp/gcc-cross/bin:$PATH

El compilador cruzado GCC aarch64-linux sobre tu sistema Slackware ARM está listo para rock-n-roll!.

Construyendo el kernel arm64, modulos, y and árbol de dispositivos blob (DTB)

Para construir el kernel aarch64, módulos y el árbol de dispositivos blob(s) es exactamente el mismo método que el que se utilizaría en circunstancias normales. Comandos como 'make bzImage && make modules && make modules_install' pueden ser demasiado familiares para usted. En nuestro caso, CFLAGS será usado para instruir al compilador cruzado de GCC a construir específicamente para la arquitectura aarch64 (arm64).

Creando el archivo .config del kernel arm64

Primero de todo, como siempre, es necesario estar en el directorio fuente del núcleo de Raspberry Pi Linux que está en la carpeta 'build-dir'. Luego necesita crear un archivo .config para el kernel, basado en los parámetros de Raspberry Pi 3. Para simplificar, puede generar un archivo por defecto .config (defconfig). Este archivo contiene la configuración del núcleo de Linux para el núcleo arm64 que va a construir. Para ello ejecute los siguientes comandos:

cd /tmp/build-dir/linux
make -j4 ARCH=arm64 CROSS_COMPILE=aarch64-linux- bcmrpi3_defconfig
Tome nota aquí de los CFLAGS que han sido especificados. Ya deberían ser auto-explicativos. Ponga especial atención al final '-' de 'CROSS_COMPILE=aarch64-linux-' porque eso NO es un error tipográfico. ¡Esto tiene que ser así!

Construyendo el kernel arm64

Lo siguiente es construir el kernel, basado en el archivo .config que acabas de crear. Una vez más, usarás el mismo CFLAGS que antes. Puede incluso establecer una 'LOCALVERSION' aquí que añada lo que haya establecido al final de la versión del núcleo (por ejemplo, LOCALVERSION=“-arm64” le daría eventualmente 4.8.13-v8–arm64) una vez que el núcleo y los módulos hayan sido construidos. A modo de ejemplo lo usaremos aquí.

make -j4 Image ARCH=arm64 CROSS_COMPILE=aarch64-linux- LOCALVERSION="-arm64"

Así, aquí `make' construye el núcleo que se guardará con el nombre 'Image'. El resto debe estar familiarizado. Este proceso tomará un tiempo. Tal vez una hora más o menos.

Construyendo el árbol de dispositivos blob(s)

El árbol de dispositivos es un medio para describir el hardware que el núcleo (kernel) lee en el momento del arranque para saber qué hardware existe en el sistema. En nuestro caso, se relaciona con la Raspberry Pi 3 y es el método por el cual el sistema sabe qué controladores cargar para el hardware. En los dispositivos basados en ARM, el uso de árboles de dispositivos se ha vuelto obligatorio para todos los nuevos SOCs, incluyendo la Raspberry Pi. Los arboles de dispositivos blobs que se construirán son 'bcm2710-rpi-3-b.dtb' y 'bcm2837-rpi-3-b.dtb'.

Para construir el árbol de dispositivos blob(s) para la Raspberry Pi corra los siguientes comandos:

make -j4 dtbs ARCH=arm64 CROSS_COMPILE=aarch64-linux- LOCALVERSION="-arm64"

Es básicamente lo mismo que hiciste para construir el núcleo, sólo que donde 'Image' es sustituido por 'dtbs'.

Construyendo los módulos arm64

Para construir los módulos del núcleo se hace de la misma manera que antes. Ejecute el siguiente comando:

make -j4 modules ARCH=arm64 CROSS_COMPILE=aarch64-linux- LOCALVERSION="-arm64"

Observe cómo cada vez que el comando es el mismo, excepto cuando se especifica lo que está construyendo. Si ha establecido una 'LOCALVERSION' entonces debe ser la misma para construir el kernel y los módulos. Este proceso probablemente tardará un poco más que la construcción del núcleo arm64.

Instalando los módulos arm64

Una vez que los módulos han sido construidos, se debe hacer 'make modules_install'. El proceso debería instalar los módulos de tu núcleo (kernel) en el directorio '/tmp/lib/modules/4.8.13-v8'.

Usted podría construir módulos out-of-tree/ kernel pero, para mantener las cosas simples, los va a instalar en la ubicación usual.Una vez más, usted usará el mismo CFLAGS que antes pero sin ninguna configuración de 'LOCALVERSION'. Primero necesitas convertirte en usuario 'root' e introducir una contraseña cuando se te pida. Para instalar los módulos de aarch64 ejecute los siguientes comandos:

su -
make -j4 modules_install ARCH=arm64 CROSS_COMPILE=aarch64-linux-
You need to be 'root' user to install the arm64 modules. A normal user does not have the rights to do so!

So, as I'm a great believer in being thorough, I always verify things at every opportunity. Just to be sure, if nothing else, because it's always a good policy. Make sure the files and directories you have just spent quite a bit of time compiling actually do exist on your system and that they're in the right place. If this is the first time you have installed the GCC cross-compiler on your system and/or built the kernel, modules, and device tree blob(s), then it goes without saying. You could actually do this after each build process, which I often do as well.

ls -lah arch/arm64/boot/Image 
la -lah arch/arm64/boot/dts/broadcom/bcm*-rpi-3-b.dtb
ls -lah /lib/modules/4.8.13-v8*

If you can see that they all exist, then everything has worked as planned.

Copying the arm64 kernel, modules, and device tree blobs (DTB)

Connect the (spare) microSD card containing a working Slackware ARM current system to your Raspberry Pi 3 using a USB microSD card reader. You'll need to mount the partitions first, before copying the arm64 kernel, modules, and device tree blob(s) onto it.

You should still be logged in as 'root' user. If not, type the following command and enter the passwd for the 'root' user when prompted:

su -
You need to be 'root' user to carry out any mount procedures. A normal user does not have the rights to do so!

As 'root' user type the following command:

fdisk -l

This should show you which device the (spare) microSD card is using on your system. In our case it's a 32GB card and has been identified as '/dev/sda', as shown below. This tells us that '/dev/sda1' is our /boot partition and '/dev/sda3' is our root filesystem partition. Yours may be allocated differently so bear that in mind.

Device     Boot  Start      End  Sectors  Size Id Type
/dev/sda1  *        32   195327   195296 95.4M  c W95 FAT32 (LBA)
/dev/sda2       196608   720895   524288  256M 82 Linux swap
/dev/sda3       720896 61145087 60424192 28.8G 83 Linux

In order to mount the partitions you first need to create mount directories. Working in the /tmp directory you can do it like this:

cd /tmp
mkdir rpi-boot
mkdir rpi-root
mount /dev/sda1 rpi-boot
mount /dev/sda3 rpi-root

To check that you've done this correctly, use the 'mount' command. The output from this should give you something similar to the following:

/dev/mmcblk0p3 on / type ext4 (rw)
proc on /proc type proc (rw)
sysfs on /sys type sysfs (rw)
tmpfs on /dev/shm type tmpfs (rw)
/dev/mmcblk0p1 on /boot type vfat (rw,fmask=177,dmask=077)
/dev/sda1 on /tmp/rpi-boot type vfat (rw)
/dev/sda3 on /tmp/rpi-root type ext4 (rw)

The next thing to do is copy the arm64 kernel, modules, and device tree blobs to your newly mounted directories. It's important to get this right. After all the hard work you've done it would be a shame to mess it up at this stage.

To copy these files, run the following commands, as 'root' user:

cp build-dir/linux/arch/arm64/boot/Image rpi-boot/boot/kernel8.img
cp build-dir/linux/arch/arm64/boot/dts/broadcom/bcm*-rpi-3-b.dtb rpi-boot/boot
cp -rv /lib/modules/4.8.13-v8* rpi-root/lib/modules/

Once you have done that, check that the files you have copied are present and in the right place.

ls -lah rpi-boot/boot/kernel*
ls -lah rpi-boot/boot/bcm*-rpi-3-b.dtb 
ls -lah rpi-root/lib/modules/4.8.13-v8*

If it all looks fine and dandy then the next thing you need to do is delete the old armv7 kernel in the rpi-boot/boot directory. This old kernel is named 'kernel7.img' and to avoid any conflicts with the new arm64 'kernel8.img' you should remove it.

rm -rf rpi-boot/kernel7.img 

No changes to the config.txt or cmdline.txt file(s) should be necessary. If you are using a recent blootloader/GPU firmware version (i.e. post-September 2016) then nothing else needs to be changed or deleted. The system should boot using all your existing settings.

Now you can unmount the previously mounted directories.

umount rpi-boot
umount rpi-root

Booting Slackware ARM aarch64

Power off your Raspberry Pi.

poweroff

Remove the USB microSD card reader and swap microSD cards. Power on the Raspberry Pi and boot the microSD card on which you copied the arm64 kernel, modules, and device tree blobs.

El resultado final

After booting the system with the arm64 kernel, I logged in remotely via SSH as 'root' user. Then I ran the following commands:

login as: root
root@192.168.10.33's password:
Last login: Sat Dec 17 20:32:50 2016 from 192.168.10.10
Linux 4.8.13-v8-arm64.
root@drie:~# cat /proc/version
Linux version 4.8.13-v8-arm64 (exaga@drie) (gcc version 5.4.0 (GCC) ) #2 SMP Fri Dec 16 18:43:38 GMT 2016
root@drie:~# uname -a
Linux drie 4.8.13-v8-arm64 #2 SMP Fri Dec 16 18:43:38 GMT 2016 aarch64 GNU/Linux
root@drie:~# cat /etc/slackware-version
Slackware 14.2
root@drie:~# cat /proc/device-tree/model
Raspberry Pi 3 Model B Rev 1.2
root@drie:~# cat /proc/cmdline | awk -v RS=" " -F= '/serial/ { print $2 }'
0x4135b94e 
root@drie:~#

Although I've already come across a few things which need some work, and attention, it's a start. I hope to find more time to devote towards Slackware arm64 over Christmas and the New Year 2017.

Thanks for being interested. <3

Fuentes

ftp://ftp.arm.slackware.com/slackwarearm/slackwarearm-current/slackware/a/gawk-4.1.4-arm-1.txz # Slackware ARM current - gawk package.
ftp://ftp.arm.slackware.com/slackwarearm/slackwarearm-current/slackware/d/git-2.11.0-arm-1.txz # Slackware ARM current - git package.
ftp://ftp.arm.slackware.com/slackwarearm/slackwarearm-current/slackware/d/bison-3.0.4-arm-1.txz # Slackware ARM current - bison package.
ftp://ftp.arm.slackware.com/slackwarearm/slackwarearm-current/slackware/d/flex-2.6.0-arm-1.txz # Slackware ARM current - flex package.
http://arm.slackware.com/FAQs # Slackware ARM Linux Project Frequently Asked Questions.
http://wiki.osdev.org/GCC_Cross-Compiler # GCC cross-compiler documentation.
https://www.raspberrypi.org/documentation/linux/kernel # Raspberry Pi Linux kernel documentation.
https://www.github.com/raspberrypi/ # Raspberry Pi Foundation GitHub repository Linux kernel, bootloader/GPU firmware.
https://ftp.gnu.org/gnu/ # GCC, binutils, glibc, gmp, mpc, mpfr package source
ftp://gcc.gnu.org/pub/gcc/infrastructure # cloog, isl package source

  • Escrito originalmente por Exaga.

 es:howtos:hardware:arm:gcc_aarch64_cross-compiler ()