Bagaimana cara menginstal kompiler silang Raspberry Pi di mesin host Linux saya?

Saya mencoba melakukan kompilasi silang untuk Raspberry Pi yang bekerja di mesin Ubuntu saya.

Selama upaya awal saya, saya menggunakan kompiler arm-linux-gnueabi, yang tersedia di repo Ubuntu. Saya mendapatkan ini bekerja. Saya dapat membangun semua dependensi saya dan menggunakan kompiler silang dalam proyek cmake saya.

Namun, saya yakin saya harus menggunakan versi hf, jadi saya beralih ke arm-linux-gnueabihf. Kemudian saya menyadari bahwa ini tidak berfungsi dengan Raspberry Pi karena armv6.

Setelah beberapa Googling, saya kemudian menemukan toolchain yang sudah dibuat sebelumnya dari GitHub .

Saya mengunduh toolchain, tetapi saya tidak begitu mengerti bagaimana cara "menginstal" nya. Saya mengekstrak file ke direktori home saya. Struktur direktori terlihat seperti ini:

/gcc-linearo-arm-linux-gnueabihf-raspbian
    /arm-linux-gnueabihf
        /bin
            (contains g++, gcc, etc)
        /lib
            (contains libstdc++ library)
    /bin
        (contains arm-linux-gnueabihf-g++, arm-linux-gnueabihf-...)
    /lib
        (gcc lib stuff)

Jika saya mengubah direktori ke folder bin INNER, saya dapat menyusun program uji dari terminal tanpa masalah.

~/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/
arm-linux-gnueabihf/bin$ g++ test.cpp -o test

Saya kemudian mencoba untuk mengkompilasi program uji di folder tempat sampah OUTER, yang berisi versi alat yang diawali.

 ~/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/bin$ 
 arm-linux-gnueabihf-g++ test.cpp -o test

Namun, ketika saya mencoba menggunakan kompiler sekarang (dari luar direktori bin bagian dalam), ia tidak dapat menemukan perpustakaan bersama libstdc ++ yang disertakan dengan toolchain:

arm-linux-gnueabihf-gcc: error while loading shared libraries: 
libstdc++.so.6: cannot open shared object file: No such file or directory.

Selain itu, saya ingin dapat menggunakan kompiler tanpa harus membuka direktori bin. Jadi saya mencoba menambahkan direktori bin OUTER (karena saya ingin versi awalan) dan kedua direktori lib ke PATH saya:

export PATH=$PATH:~/tools/.../bin
export PATH=$PATH:~/tools/.../lib
export PATH=$PATH:~/tools/.../.../lib

Namun, ini menghasilkan kesalahan yang sama. Bagaimana saya harus "menginstal" toolchain sehingga saya dapat menggunakan toolchain dari mana saja, seperti yang saya bisa ketika saya menggunakan cross-compiler dari repo Ubuntu?

Saya akan mencoba menulis ini sebagai tutorial untuk Anda agar mudah diikuti.

CATATAN: Tutorial ini hanya berfungsi untuk gambar raspbian lama. Untuk Raspbian yang lebih baru berdasarkan Debian Buster, lihat petunjuk berikut di utas ini: https://stackoverflow.com/a/58559140/869402

Prasyarat

Sebelum Anda mulai, Anda perlu memastikan yang berikut ini telah diinstal:

apt-get install git rsync cmake ia32-libs

Mari kita menyusun ulang Pie!

Mulailah dengan membuat folder di direktori home Anda dengan nama raspberrypi.

Masuk ke folder ini dan tarik ke bawah seluruh folder alat yang Anda sebutkan di atas:

git clone git://github.com/raspberrypi/tools.git

Anda ingin menggunakan yang berikut dari 3 yang gcc-linaro-arm-linux-gnueabihf-raspbian, jika saya tidak salah baca.

Masuk ke direktori home Anda dan tambahkan:

export PATH=$PATH:$HOME/raspberrypi/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/bin

ke akhir file bernama ~/.bashrc

Sekarang Anda dapat keluar dan masuk kembali (yaitu memulai kembali sesi terminal Anda), atau menjalankan . ~/.bashrcdi terminal Anda untuk mengambilPATH tambahan dalam sesi terminal Anda saat ini.

Sekarang, verifikasi bahwa Anda dapat mengakses kompiler arm-linux-gnueabihf-gcc -v. Anda harus mendapatkan sesuatu seperti ini:

Using built-in specs.
COLLECT_GCC=arm-linux-gnueabihf-gcc
COLLECT_LTO_WRAPPER=/home/tudhalyas/raspberrypi/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/bin/../libexec/gcc/arm-linux-gnueabihf/4.7.2/lto-wrapper
Target: arm-linux-gnueabihf
Configured with: /cbuild/slaves/oort61/crosstool-ng/builds/arm-linux-gnueabihf-raspbian-linux/.b
 uild/src/gcc-linaro-4.7-2012.08/configure --build=i686-build_pc-linux-gnu --host=i686-build_pc-
 linux-gnu --target=arm-linux-gnueabihf --prefix=/cbuild/slaves/oort61/crosstool-ng/builds/arm-l
 inux-gnueabihf-raspbian-linux/install --with-sysroot=/cbuild/slaves/oort61/crosstool-ng/builds/
 arm-linux-gnueabihf-raspbian-linux/install/arm-linux-gnueabihf/libc --enable-languages=c,c++,fo
 rtran --disable-multilib --with-arch=armv6 --with-tune=arm1176jz-s --with-fpu=vfp --with-float=
 hard --with-pkgversion='crosstool-NG linaro-1.13.1+bzr2458 - Linaro GCC 2012.08' --with-bugurl=
 https://bugs.launchpad.net/gcc-linaro --enable-__cxa_atexit --enable-libmudflap --enable-libgom
 p --enable-libssp --with-gmp=/cbuild/slaves/oort61/crosstool-ng/builds/arm-linux-gnueabihf-rasp
 bian-linux/.build/arm-linux-gnueabihf/build/static --with-mpfr=/cbuild/slaves/oort61/crosstool-
 ng/builds/arm-linux-gnueabihf-raspbian-linux/.build/arm-linux-gnueabihf/build/static --with-mpc
 =/cbuild/slaves/oort61/crosstool-ng/builds/arm-linux-gnueabihf-raspbian-linux/.build/arm-linux-
 gnueabihf/build/static --with-ppl=/cbuild/slaves/oort61/crosstool-ng/builds/arm-linux-gnueabihf
 -raspbian-linux/.build/arm-linux-gnueabihf/build/static --with-cloog=/cbuild/slaves/oort61/cros
 stool-ng/builds/arm-linux-gnueabihf-raspbian-linux/.build/arm-linux-gnueabihf/build/static --wi
 th-libelf=/cbuild/slaves/oort61/crosstool-ng/builds/arm-linux-gnueabihf-raspbian-linux/.build/a
 rm-linux-gnueabihf/build/static --with-host-libstdcxx='-L/cbuild/slaves/oort61/crosstool-ng/bui
 lds/arm-linux-gnueabihf-raspbian-linux/.build/arm-linux-gnueabihf/build/static/lib -lpwl' --ena
 ble-threads=posix --disable-libstdcxx-pch --enable-linker-build-id --enable-plugin --enable-gol
 d --with-local-prefix=/cbuild/slaves/oort61/crosstool-ng/builds/arm-linux-gnueabihf-raspbian-li
 nux/install/arm-linux-gnueabihf/libc --enable-c99 --enable-long-long
Thread model: posix
gcc version 4.7.2 20120731 (prerelease) (crosstool-NG linaro-1.13.1+bzr2458 - Linaro GCC 2012.08
 )

Tapi hey! Saya melakukan itu dan libs masih tidak berfungsi!

Kami belum selesai! Sejauh ini, kami hanya melakukan dasar-dasarnya.

Di raspberrypifolder Anda , buat folder bernama rootfs.

Sekarang Anda perlu menyalin seluruh direktori /libdan /usrke folder yang baru dibuat ini. Saya biasanya memunculkan gambar rpi dan menyalinnya melalui rsync:

rsync -rl --delete-after --safe-links pi@192.168.1.PI:/{lib,usr} $HOME/raspberrypi/rootfs

di mana 192.168.1.PIdiganti dengan IP Raspberry Pi Anda.

Sekarang, kita perlu menulis cmakefile konfigurasi. Buka ~/home/raspberrypi/pi.cmakedi editor favorit Anda dan masukkan yang berikut ini:

SET(CMAKE_SYSTEM_NAME Linux)
SET(CMAKE_SYSTEM_VERSION 1)
SET(CMAKE_C_COMPILER $ENV{HOME}/raspberrypi/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/bin/arm-linux-gnueabihf-gcc)
SET(CMAKE_CXX_COMPILER $ENV{HOME}/raspberrypi/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/bin/arm-linux-gnueabihf-g++)
SET(CMAKE_FIND_ROOT_PATH $ENV{HOME}/raspberrypi/rootfs)
SET(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
SET(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
SET(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

Sekarang Anda seharusnya dapat mengkompilasi cmakeprogram Anda hanya dengan menambahkan tanda tambahan ini:-D CMAKE_TOOLCHAIN_FILE=$HOME/raspberrypi/pi.cmake .

Menggunakan contoh cmake hello world :

git clone https://github.com/jameskbride/cmake-hello-world.git 
cd cmake-hello-world
mkdir build
cd build
cmake -D CMAKE_TOOLCHAIN_FILE=$HOME/raspberrypi/pi.cmake ../
make
scp CMakeHelloWorld pi@192.168.1.PI:/home/pi/
ssh pi@192.168.1.PI ./CMakeHelloWorld

Dibuat untuk image Raspbian Debian Buster dan ARMv6 yang lebih baru

Jawaban oleh @Stenyg hanya berfungsi untuk gambar Raspbian yang lebih lama. Raspbian yang baru dirilis berdasarkan Debian Buster membutuhkan toolchain yang diperbarui:

Di Debian Buster, gcc compiler dan glibc telah diupdate ke versi 8.3. Toolchain git://github.com/raspberrypi/tools.gitmasih didasarkan pada versi gcc 6 yang lebih lama. Ini berarti bahwa penggunaan git://github.com/raspberrypi/tools.gitakan menyebabkan banyak kesalahan kompilasi.

Tutorial ini didasarkan pada jawaban @Stenyg. Selain banyak solusi lain di internet, tutorial ini juga mendukung Rasperry Pi yang lebih lama (A, B, B +, Zero ) berdasarkan CPU ARMv6. Lihat juga: GCC 8 Cross Compiler mengeluarkan ARMv7 yang dapat dieksekusi, bukan ARMv6

Siapkan toolchain

Tidak ada repositori git resmi yang berisi toolchain yang diperbarui (Lihat https://github.com/raspberrypi/tools/issues/102 ).

Saya membuat repositori github baru yang mencakup membangun dan toolchain yang telah dikompilasi untuk ARMv6 berdasarkan GCC8 dan yang lebih baru:

https://github.com/Pro/raspi-toolchain

Seperti yang disebutkan dalam readme proyek, berikut adalah langkah-langkah untuk mendapatkan toolchain. Anda juga dapat membuatnya sendiri (lihat README untuk detail lebih lanjut).

1. Unduh toolchain:

wget https://github.com/Pro/raspi-toolchain/releases/latest/download/raspi-toolchain.tar.gz

2. Ekstrak. Catatan: Toolchain harus ada /opt/cross-pi-gcckarena tidak bergantung pada lokasi.

sudo tar xfz raspi-toolchain.tar.gz --strip-components=1 -C /opt

3. Kamu selesai! Toolchain sekarang sudah masuk/opt/cross-pi-gcc

4. Opsional, tambahkan toolchain ke jalur Anda, dengan menambahkan:

export PATH=$PATH:/opt/cross-pi-gcc/bin

ke akhir file bernama ~/.bashrc

Sekarang Anda dapat keluar dan masuk kembali (yaitu memulai kembali sesi terminal Anda), atau menjalankan . ~/.bashrcdi terminal Anda untuk mengambilPATH tambahan dalam sesi terminal Anda saat ini.

Dapatkan pustaka dari Raspberry PI

Untuk mengkompilasi silang untuk Raspberry Pi Anda sendiri, yang mungkin memiliki beberapa pustaka khusus yang diinstal, Anda perlu memasukkan pustaka ini ke host Anda.

Buat folder $HOME/raspberrypi. Di raspberrypifolder Anda , buat folder bernama rootfs.

Sekarang Anda perlu menyalin seluruh direktori /libdan /usrke folder yang baru dibuat ini. Saya biasanya memunculkan gambar rpi dan menyalinnya melalui rsync:

rsync -vR --progress -rl --delete-after --safe-links pi@192.168.1.PI:/{lib,usr,opt/vc/lib} $HOME/raspberrypi/rootfs

di mana 192.168.1.PIdiganti dengan IP Raspberry Pi Anda.

Gunakan CMake untuk mengkompilasi proyek Anda

Untuk memberi tahu CMake agar menggunakan toolchain Anda sendiri, Anda perlu memiliki file toolchain yang menginisialisasi pengaturan compiler.

Dapatkan file toolchain ini dari sini: https://github.com/Pro/raspi-toolchain/blob/master/Toolchain-rpi.cmake

Sekarang Anda seharusnya dapat mengkompilasi cmakeprogram Anda hanya dengan menambahkan tanda tambahan ini: -D CMAKE_TOOLCHAIN_FILE=$HOME/raspberrypi/pi.cmakedan mengatur variabel lingkungan yang benar:

export RASPBIAN_ROOTFS=$HOME/raspberry/rootfs
export PATH=/opt/cross-pi-gcc/bin:$PATH
export RASPBERRY_VERSION=1
cmake -DCMAKE_TOOLCHAIN_FILE=$HOME/raspberry/Toolchain-rpi.cmake ..

Contoh hello world ditampilkan di sini: https://github.com/Pro/raspi-toolchain/blob/master/build_hello_world.sh

Aku tidak bisa mendapatkan compiler ( x64versi) untuk menggunakan sysrootsampai saya menambahkan SET(CMAKE_SYSROOT $ENV{HOME}/raspberrypi/rootfs)untuk pi.cmake.

Untuk host Windows, saya sangat merekomendasikan tutorial ini ::

• Unduh dan instal toolchain
• Sinkronkan sysroot dengan direktori include / lib RPi Anda
• Kompilasi kode Anda
• Seret dan jatuhkan file yang dapat dieksekusi ke RPi Anda menggunakan SmarTTY
• Menjalankannya!

Tidak lebih, tidak kurang!

GNU Toolchain prebuilt tersedia untuk Raspberry, Beaglebone, Cubieboard, AVR (Atmel) dan banyak lagi

Anda juga bisa menggunakan dentang . Dulu lebih cepat dari GCC, dan sekarang sudah cukup stabil. Jauh lebih mudah untuk membangun dentang dari sumber ( Anda benar-benar dapat minum secangkir kopi selama proses pembuatan ).

Pendeknya:

1. Dapatkan binari clang (sudo apt-get install clang) .. atau unduh dan buat ( baca instruksi di sini )
2. Pasang rootf raspberry Anda (mungkin rootf asli yang dipasang melalui sshfs, atau gambar).

3. Kompilasi kode Anda:

   path/to/clang --target=arm-linux-gnueabihf --sysroot=/some/path/arm-linux-gnueabihf/sysroot my-happy-program.c -fuse-ld=lld

Secara opsional, Anda dapat menggunakan binutils arm-linux-gnueabihf lama. Kemudian Anda dapat menghapus tanda "-fuse-ld = lld" di bagian akhir.

Di bawah ini adalah file toolchain cmake saya.

toolchain.cmake

set(CMAKE_SYSTEM_VERSION 1)
set(CMAKE_SYSTEM_NAME Linux)
set(CMAKE_SYSTEM_PROCESSOR arm)

# Custom toolchain-specific definitions for your project
set(PLATFORM_ARM "1")
set(PLATFORM_COMPILE_DEFS "COMPILE_GLES")

# There we go!
# Below, we specify toolchain itself!

set(TARGET_TRIPLE arm-linux-gnueabihf)

# Specify your target rootfs mount point on your compiler host machine
set(TARGET_ROOTFS /Volumes/rootfs-${TARGET_TRIPLE})

# Specify clang paths
set(LLVM_DIR /Users/stepan/projects/shared/toolchains/llvm-7.0.darwin-release-x86_64/install)
set(CLANG ${LLVM_DIR}/bin/clang)
set(CLANGXX ${LLVM_DIR}/bin/clang++)

# Specify compiler (which is clang)
set(CMAKE_C_COMPILER   ${CLANG})
set(CMAKE_CXX_COMPILER ${CLANGXX})

# Specify binutils

set (CMAKE_AR      "${LLVM_DIR}/bin/llvm-ar" CACHE FILEPATH "Archiver")
set (CMAKE_LINKER  "${LLVM_DIR}/bin/llvm-ld" CACHE FILEPATH "Linker")
set (CMAKE_NM      "${LLVM_DIR}/bin/llvm-nm" CACHE FILEPATH "NM")
set (CMAKE_OBJDUMP "${LLVM_DIR}/bin/llvm-objdump" CACHE FILEPATH "Objdump")
set (CMAKE_RANLIB  "${LLVM_DIR}/bin/llvm-ranlib" CACHE FILEPATH "ranlib")

# You may use legacy binutils though.
#set(BINUTILS /usr/local/Cellar/arm-linux-gnueabihf-binutils/2.31.1)
#set (CMAKE_AR      "${BINUTILS}/bin/${TARGET_TRIPLE}-ar" CACHE FILEPATH "Archiver")
#set (CMAKE_LINKER  "${BINUTILS}/bin/${TARGET_TRIPLE}-ld" CACHE FILEPATH "Linker")
#set (CMAKE_NM      "${BINUTILS}/bin/${TARGET_TRIPLE}-nm" CACHE FILEPATH "NM")
#set (CMAKE_OBJDUMP "${BINUTILS}/bin/${TARGET_TRIPLE}-objdump" CACHE FILEPATH "Objdump")
#set (CMAKE_RANLIB  "${BINUTILS}/bin/${TARGET_TRIPLE}-ranlib" CACHE FILEPATH "ranlib")

# Specify sysroot (almost same as rootfs)
set(CMAKE_SYSROOT ${TARGET_ROOTFS})
set(CMAKE_FIND_ROOT_PATH ${TARGET_ROOTFS})

# Specify lookup methods for cmake
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

# Sometimes you also need this:
# set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)

# Specify raspberry triple
set(CROSS_FLAGS "--target=${TARGET_TRIPLE}")

# Specify other raspberry related flags
set(RASP_FLAGS "-D__STDC_CONSTANT_MACROS -D__STDC_LIMIT_MACROS")

# Gather and distribute flags specified at prev steps.
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${CROSS_FLAGS} ${RASP_FLAGS}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CROSS_FLAGS} ${RASP_FLAGS}")

# Use clang linker. Why?
# Well, you may install custom arm-linux-gnueabihf binutils,
# but then, you also need to recompile clang, with customized triple;
# otherwise clang will try to use host 'ld' for linking,
# so... use clang linker.
set(CMAKE_EXE_LINKER_FLAGS ${CMAKE_EXE_LINKER_FLAGS} -fuse-ld=lld)

Saya tidak dapat mengkompilasi QT5 dengan salah satu rantai alat (cukup usang) dari git: //github.com/raspberrypi/tools.git. Skrip konfigurasi terus gagal dengan kesalahan "tidak dapat menentukan arsitektur" dan dengan masalah jalur besar untuk direktori penyertaan. Apa yang berhasil bagi saya adalah menggunakan toolchain Linaro

http://releases.linaro.org/components/toolchain/binaries/4.9-2016.02/arm-linux-gnueabihf/runtime-linaro-gcc4.9-2016.02-arm-linux-gnueabihf.tar.xz

dalam kombinasi dengan

https://raw.githubusercontent.com/riscv/riscv-poky/master/scripts/sysroot-relativelinks.py

Gagal untuk memperbaiki symlink dari sysroot menyebabkan kesalahan simbol yang tidak ditentukan seperti yang dijelaskan di sini: Kesalahan dalam membangun pustaka Qt untuk raspberry pi Ini terjadi pada saya ketika saya mencoba skrip fixQualifiedLibraryPaths dari tools.git. Yang lainnya dijelaskan secara rinci di http://wiki.qt.io/RaspberryPi2EGLFS . Pengaturan konfigurasi saya adalah:

./configure -opengl es2 -device linux-rpi3-g ++ -device-option CROSS_COMPILE = / usr / local / rasp / gcc-linaro-4.9-2016.02-x86_64_arm-linux-gnueabihf / bin / arm-linux-gnueabihf- -sysroot / usr / local / rasp / sysroot -opensource -confirm-license -optimized-qmake -reduce-ekspor -release -make libs -prefix / usr / local / qt5pi -hostprefix / usr / local / qt5pi

dengan / usr / local / rasp / sysroot menjadi jalur salinan sistem Raspberry Pi 3 Raspbian (Jessie) lokal saya dan / usr / local / qt5pi menjadi jalur dari QT yang dikompilasi silang yang juga harus disalin ke perangkat. Ketahuilah bahwa Jessie hadir dengan GCC 4.9.2 saat Anda memilih toolchain.

Pertanyaan awal telah diposting beberapa waktu yang lalu dan sementara itu Debian telah membuat kemajuan besar di bidang dukungan multiarch.

Multiarch adalah pencapaian luar biasa untuk kompilasi silang!

Singkatnya, langkah-langkah berikut diperlukan untuk memanfaatkan multiarch untuk kompilasi silang Raspbian Jessie:

• Di host Ubuntu Anda, instal Debian Jessie amd64 dalam chroot atau container LXC.
• Aktifkan armhf arsitektur asing.
• Instal kompiler silang dari repositori alat emdebian.
• Sesuaikan kompiler silang (ini akan menghasilkan kode untuk ARMv7-A secara default) dengan menulis file spesifikasi gcc khusus.
• Instal pustaka armhf (libstdc ++ dll.) Dari repositori Raspbian.
• Buat kode sumber Anda.

Karena ini banyak pekerjaan, saya telah mengotomatiskan pengaturan di atas. Anda dapat membacanya di sini:

Kompilasi Silang untuk Raspbian

ada CDP Studio IDE tersedia yang membuat kompilasi silang dan penerapan cukup sederhana baik dari windows maupun linux dan Anda cukup mencentang kotak centang raspberry toolchain selama instalasi. (PS. Memiliki dukungan GPIO dan I2C sehingga tidak diperlukan kode untuk mengaksesnya)

Demo IDE penggunaan raspberry ada di sini: https://youtu.be/4SVZ68sQz5U

dan Anda dapat mengunduh IDE di sini: https://cdpstudio.com/home-edition